Skip to main content

winterbaume_backup/
model.rs

1//! Auto-generated types from Smithy models.
2//! Do not edit manually. Regenerate with:
3//!   smithy-codegen gen-serializers winterbaume-backup
4
5#![allow(non_camel_case_types, clippy::upper_case_acronyms, dead_code)]
6
7use serde::{Deserialize, Serialize};
8
9#[derive(Debug, Clone, Default, Deserialize, Serialize)]
10pub struct AssociateBackupVaultMpaApprovalTeamInput {
11    #[serde(rename = "BackupVaultName")]
12    #[serde(default)]
13    pub backup_vault_name: String,
14    #[serde(rename = "MpaApprovalTeamArn")]
15    #[serde(default)]
16    pub mpa_approval_team_arn: String,
17    #[serde(rename = "RequesterComment")]
18    #[serde(default)]
19    #[serde(skip_serializing_if = "Option::is_none")]
20    pub requester_comment: Option<String>,
21}
22
23#[derive(Debug, Clone, Default, Deserialize, Serialize)]
24pub struct CancelLegalHoldInput {
25    #[serde(rename = "CancelDescription")]
26    #[serde(default)]
27    pub cancel_description: String,
28    #[serde(rename = "LegalHoldId")]
29    #[serde(default)]
30    pub legal_hold_id: String,
31    #[serde(rename = "RetainRecordInDays")]
32    #[serde(default)]
33    #[serde(skip_serializing_if = "Option::is_none")]
34    pub retain_record_in_days: Option<i64>,
35}
36
37#[derive(Debug, Clone, Default, Deserialize, Serialize)]
38pub struct CancelLegalHoldOutput {}
39
40#[derive(Debug, Clone, Default, Deserialize, Serialize)]
41pub struct CreateBackupPlanInput {
42    #[serde(rename = "BackupPlan")]
43    #[serde(default)]
44    pub backup_plan: BackupPlanInput,
45    #[serde(rename = "BackupPlanTags")]
46    #[serde(default)]
47    #[serde(skip_serializing_if = "Option::is_none")]
48    pub backup_plan_tags: Option<std::collections::HashMap<String, String>>,
49    #[serde(rename = "CreatorRequestId")]
50    #[serde(default)]
51    #[serde(skip_serializing_if = "Option::is_none")]
52    pub creator_request_id: Option<String>,
53}
54
55#[derive(Debug, Clone, Default, Deserialize, Serialize)]
56pub struct BackupPlanInput {
57    #[serde(rename = "AdvancedBackupSettings")]
58    #[serde(default)]
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub advanced_backup_settings: Option<Vec<AdvancedBackupSetting>>,
61    #[serde(rename = "BackupPlanName")]
62    #[serde(default)]
63    pub backup_plan_name: String,
64    #[serde(rename = "Rules")]
65    #[serde(default)]
66    pub rules: Vec<BackupRuleInput>,
67    #[serde(rename = "ScanSettings")]
68    #[serde(default)]
69    #[serde(skip_serializing_if = "Option::is_none")]
70    pub scan_settings: Option<Vec<ScanSetting>>,
71}
72
73#[derive(Debug, Clone, Default, Deserialize, Serialize)]
74pub struct AdvancedBackupSetting {
75    #[serde(rename = "BackupOptions")]
76    #[serde(default)]
77    #[serde(skip_serializing_if = "Option::is_none")]
78    pub backup_options: Option<std::collections::HashMap<String, String>>,
79    #[serde(rename = "ResourceType")]
80    #[serde(default)]
81    #[serde(skip_serializing_if = "Option::is_none")]
82    pub resource_type: Option<String>,
83}
84
85#[derive(Debug, Clone, Default, Deserialize, Serialize)]
86pub struct BackupRuleInput {
87    #[serde(rename = "CompletionWindowMinutes")]
88    #[serde(default)]
89    #[serde(skip_serializing_if = "Option::is_none")]
90    pub completion_window_minutes: Option<i64>,
91    #[serde(rename = "CopyActions")]
92    #[serde(default)]
93    #[serde(skip_serializing_if = "Option::is_none")]
94    pub copy_actions: Option<Vec<CopyAction>>,
95    #[serde(rename = "EnableContinuousBackup")]
96    #[serde(default)]
97    #[serde(skip_serializing_if = "Option::is_none")]
98    pub enable_continuous_backup: Option<bool>,
99    #[serde(rename = "IndexActions")]
100    #[serde(default)]
101    #[serde(skip_serializing_if = "Option::is_none")]
102    pub index_actions: Option<Vec<IndexAction>>,
103    #[serde(rename = "Lifecycle")]
104    #[serde(default)]
105    #[serde(skip_serializing_if = "Option::is_none")]
106    pub lifecycle: Option<Lifecycle>,
107    #[serde(rename = "RecoveryPointTags")]
108    #[serde(default)]
109    #[serde(skip_serializing_if = "Option::is_none")]
110    pub recovery_point_tags: Option<std::collections::HashMap<String, String>>,
111    #[serde(rename = "RuleName")]
112    #[serde(default)]
113    pub rule_name: String,
114    #[serde(rename = "ScanActions")]
115    #[serde(default)]
116    #[serde(skip_serializing_if = "Option::is_none")]
117    pub scan_actions: Option<Vec<ScanAction>>,
118    #[serde(rename = "ScheduleExpression")]
119    #[serde(default)]
120    #[serde(skip_serializing_if = "Option::is_none")]
121    pub schedule_expression: Option<String>,
122    #[serde(rename = "ScheduleExpressionTimezone")]
123    #[serde(default)]
124    #[serde(skip_serializing_if = "Option::is_none")]
125    pub schedule_expression_timezone: Option<String>,
126    #[serde(rename = "StartWindowMinutes")]
127    #[serde(default)]
128    #[serde(skip_serializing_if = "Option::is_none")]
129    pub start_window_minutes: Option<i64>,
130    #[serde(rename = "TargetBackupVaultName")]
131    #[serde(default)]
132    pub target_backup_vault_name: String,
133    #[serde(rename = "TargetLogicallyAirGappedBackupVaultArn")]
134    #[serde(default)]
135    #[serde(skip_serializing_if = "Option::is_none")]
136    pub target_logically_air_gapped_backup_vault_arn: Option<String>,
137}
138
139#[derive(Debug, Clone, Default, Deserialize, Serialize)]
140pub struct CopyAction {
141    #[serde(rename = "DestinationBackupVaultArn")]
142    #[serde(default)]
143    pub destination_backup_vault_arn: String,
144    #[serde(rename = "Lifecycle")]
145    #[serde(default)]
146    #[serde(skip_serializing_if = "Option::is_none")]
147    pub lifecycle: Option<Lifecycle>,
148}
149
150#[derive(Debug, Clone, Default, Deserialize, Serialize)]
151pub struct Lifecycle {
152    #[serde(rename = "DeleteAfterDays")]
153    #[serde(default)]
154    #[serde(skip_serializing_if = "Option::is_none")]
155    pub delete_after_days: Option<i64>,
156    #[serde(rename = "DeleteAfterEvent")]
157    #[serde(default)]
158    #[serde(skip_serializing_if = "Option::is_none")]
159    pub delete_after_event: Option<String>,
160    #[serde(rename = "MoveToColdStorageAfterDays")]
161    #[serde(default)]
162    #[serde(skip_serializing_if = "Option::is_none")]
163    pub move_to_cold_storage_after_days: Option<i64>,
164    #[serde(rename = "OptInToArchiveForSupportedResources")]
165    #[serde(default)]
166    #[serde(skip_serializing_if = "Option::is_none")]
167    pub opt_in_to_archive_for_supported_resources: Option<bool>,
168}
169
170#[derive(Debug, Clone, Default, Deserialize, Serialize)]
171pub struct IndexAction {
172    #[serde(rename = "ResourceTypes")]
173    #[serde(default)]
174    #[serde(skip_serializing_if = "Option::is_none")]
175    pub resource_types: Option<Vec<String>>,
176}
177
178#[derive(Debug, Clone, Default, Deserialize, Serialize)]
179pub struct ScanAction {
180    #[serde(rename = "MalwareScanner")]
181    #[serde(default)]
182    #[serde(skip_serializing_if = "Option::is_none")]
183    pub malware_scanner: Option<String>,
184    #[serde(rename = "ScanMode")]
185    #[serde(default)]
186    #[serde(skip_serializing_if = "Option::is_none")]
187    pub scan_mode: Option<String>,
188}
189
190#[derive(Debug, Clone, Default, Deserialize, Serialize)]
191pub struct ScanSetting {
192    #[serde(rename = "MalwareScanner")]
193    #[serde(default)]
194    #[serde(skip_serializing_if = "Option::is_none")]
195    pub malware_scanner: Option<String>,
196    #[serde(rename = "ResourceTypes")]
197    #[serde(default)]
198    #[serde(skip_serializing_if = "Option::is_none")]
199    pub resource_types: Option<Vec<String>>,
200    #[serde(rename = "ScannerRoleArn")]
201    #[serde(default)]
202    #[serde(skip_serializing_if = "Option::is_none")]
203    pub scanner_role_arn: Option<String>,
204}
205
206#[derive(Debug, Clone, Default, Deserialize, Serialize)]
207pub struct CreateBackupPlanOutput {
208    #[serde(rename = "AdvancedBackupSettings")]
209    #[serde(default)]
210    #[serde(skip_serializing_if = "Option::is_none")]
211    pub advanced_backup_settings: Option<Vec<AdvancedBackupSetting>>,
212    #[serde(rename = "BackupPlanArn")]
213    #[serde(default)]
214    #[serde(skip_serializing_if = "Option::is_none")]
215    pub backup_plan_arn: Option<String>,
216    #[serde(rename = "BackupPlanId")]
217    #[serde(default)]
218    #[serde(skip_serializing_if = "Option::is_none")]
219    pub backup_plan_id: Option<String>,
220    #[serde(rename = "CreationDate")]
221    #[serde(default)]
222    #[serde(skip_serializing_if = "Option::is_none")]
223    pub creation_date: Option<f64>,
224    #[serde(rename = "VersionId")]
225    #[serde(default)]
226    #[serde(skip_serializing_if = "Option::is_none")]
227    pub version_id: Option<String>,
228}
229
230#[derive(Debug, Clone, Default, Deserialize, Serialize)]
231pub struct CreateBackupSelectionInput {
232    #[serde(rename = "BackupPlanId")]
233    #[serde(default)]
234    pub backup_plan_id: String,
235    #[serde(rename = "BackupSelection")]
236    #[serde(default)]
237    pub backup_selection: BackupSelection,
238    #[serde(rename = "CreatorRequestId")]
239    #[serde(default)]
240    #[serde(skip_serializing_if = "Option::is_none")]
241    pub creator_request_id: Option<String>,
242}
243
244#[derive(Debug, Clone, Default, Deserialize, Serialize)]
245pub struct BackupSelection {
246    #[serde(rename = "Conditions")]
247    #[serde(default)]
248    #[serde(skip_serializing_if = "Option::is_none")]
249    pub conditions: Option<Conditions>,
250    #[serde(rename = "IamRoleArn")]
251    #[serde(default)]
252    pub iam_role_arn: String,
253    #[serde(rename = "ListOfTags")]
254    #[serde(default)]
255    #[serde(skip_serializing_if = "Option::is_none")]
256    pub list_of_tags: Option<Vec<Condition>>,
257    #[serde(rename = "NotResources")]
258    #[serde(default)]
259    #[serde(skip_serializing_if = "Option::is_none")]
260    pub not_resources: Option<Vec<String>>,
261    #[serde(rename = "Resources")]
262    #[serde(default)]
263    #[serde(skip_serializing_if = "Option::is_none")]
264    pub resources: Option<Vec<String>>,
265    #[serde(rename = "SelectionName")]
266    #[serde(default)]
267    pub selection_name: String,
268}
269
270#[derive(Debug, Clone, Default, Deserialize, Serialize)]
271pub struct Conditions {
272    #[serde(rename = "StringEquals")]
273    #[serde(default)]
274    #[serde(skip_serializing_if = "Option::is_none")]
275    pub string_equals: Option<Vec<ConditionParameter>>,
276    #[serde(rename = "StringLike")]
277    #[serde(default)]
278    #[serde(skip_serializing_if = "Option::is_none")]
279    pub string_like: Option<Vec<ConditionParameter>>,
280    #[serde(rename = "StringNotEquals")]
281    #[serde(default)]
282    #[serde(skip_serializing_if = "Option::is_none")]
283    pub string_not_equals: Option<Vec<ConditionParameter>>,
284    #[serde(rename = "StringNotLike")]
285    #[serde(default)]
286    #[serde(skip_serializing_if = "Option::is_none")]
287    pub string_not_like: Option<Vec<ConditionParameter>>,
288}
289
290#[derive(Debug, Clone, Default, Deserialize, Serialize)]
291pub struct ConditionParameter {
292    #[serde(rename = "ConditionKey")]
293    #[serde(default)]
294    #[serde(skip_serializing_if = "Option::is_none")]
295    pub condition_key: Option<String>,
296    #[serde(rename = "ConditionValue")]
297    #[serde(default)]
298    #[serde(skip_serializing_if = "Option::is_none")]
299    pub condition_value: Option<String>,
300}
301
302#[derive(Debug, Clone, Default, Deserialize, Serialize)]
303pub struct Condition {
304    #[serde(rename = "ConditionKey")]
305    #[serde(default)]
306    pub condition_key: String,
307    #[serde(rename = "ConditionType")]
308    #[serde(default)]
309    pub condition_type: String,
310    #[serde(rename = "ConditionValue")]
311    #[serde(default)]
312    pub condition_value: String,
313}
314
315#[derive(Debug, Clone, Default, Deserialize, Serialize)]
316pub struct CreateBackupSelectionOutput {
317    #[serde(rename = "BackupPlanId")]
318    #[serde(default)]
319    #[serde(skip_serializing_if = "Option::is_none")]
320    pub backup_plan_id: Option<String>,
321    #[serde(rename = "CreationDate")]
322    #[serde(default)]
323    #[serde(skip_serializing_if = "Option::is_none")]
324    pub creation_date: Option<f64>,
325    #[serde(rename = "SelectionId")]
326    #[serde(default)]
327    #[serde(skip_serializing_if = "Option::is_none")]
328    pub selection_id: Option<String>,
329}
330
331#[derive(Debug, Clone, Default, Deserialize, Serialize)]
332pub struct CreateBackupVaultInput {
333    #[serde(rename = "BackupVaultName")]
334    #[serde(default)]
335    pub backup_vault_name: String,
336    #[serde(rename = "BackupVaultTags")]
337    #[serde(default)]
338    #[serde(skip_serializing_if = "Option::is_none")]
339    pub backup_vault_tags: Option<std::collections::HashMap<String, String>>,
340    #[serde(rename = "CreatorRequestId")]
341    #[serde(default)]
342    #[serde(skip_serializing_if = "Option::is_none")]
343    pub creator_request_id: Option<String>,
344    #[serde(rename = "EncryptionKeyArn")]
345    #[serde(default)]
346    #[serde(skip_serializing_if = "Option::is_none")]
347    pub encryption_key_arn: Option<String>,
348}
349
350#[derive(Debug, Clone, Default, Deserialize, Serialize)]
351pub struct CreateBackupVaultOutput {
352    #[serde(rename = "BackupVaultArn")]
353    #[serde(default)]
354    #[serde(skip_serializing_if = "Option::is_none")]
355    pub backup_vault_arn: Option<String>,
356    #[serde(rename = "BackupVaultName")]
357    #[serde(default)]
358    #[serde(skip_serializing_if = "Option::is_none")]
359    pub backup_vault_name: Option<String>,
360    #[serde(rename = "CreationDate")]
361    #[serde(default)]
362    #[serde(skip_serializing_if = "Option::is_none")]
363    pub creation_date: Option<f64>,
364}
365
366#[derive(Debug, Clone, Default, Deserialize, Serialize)]
367pub struct CreateFrameworkInput {
368    #[serde(rename = "FrameworkControls")]
369    #[serde(default)]
370    pub framework_controls: Vec<FrameworkControl>,
371    #[serde(rename = "FrameworkDescription")]
372    #[serde(default)]
373    #[serde(skip_serializing_if = "Option::is_none")]
374    pub framework_description: Option<String>,
375    #[serde(rename = "FrameworkName")]
376    #[serde(default)]
377    pub framework_name: String,
378    #[serde(rename = "FrameworkTags")]
379    #[serde(default)]
380    #[serde(skip_serializing_if = "Option::is_none")]
381    pub framework_tags: Option<std::collections::HashMap<String, String>>,
382    #[serde(rename = "IdempotencyToken")]
383    #[serde(default)]
384    #[serde(skip_serializing_if = "Option::is_none")]
385    pub idempotency_token: Option<String>,
386}
387
388#[derive(Debug, Clone, Default, Deserialize, Serialize)]
389pub struct FrameworkControl {
390    #[serde(rename = "ControlInputParameters")]
391    #[serde(default)]
392    #[serde(skip_serializing_if = "Option::is_none")]
393    pub control_input_parameters: Option<Vec<ControlInputParameter>>,
394    #[serde(rename = "ControlName")]
395    #[serde(default)]
396    pub control_name: String,
397    #[serde(rename = "ControlScope")]
398    #[serde(default)]
399    #[serde(skip_serializing_if = "Option::is_none")]
400    pub control_scope: Option<ControlScope>,
401}
402
403#[derive(Debug, Clone, Default, Deserialize, Serialize)]
404pub struct ControlInputParameter {
405    #[serde(rename = "ParameterName")]
406    #[serde(default)]
407    #[serde(skip_serializing_if = "Option::is_none")]
408    pub parameter_name: Option<String>,
409    #[serde(rename = "ParameterValue")]
410    #[serde(default)]
411    #[serde(skip_serializing_if = "Option::is_none")]
412    pub parameter_value: Option<String>,
413}
414
415#[derive(Debug, Clone, Default, Deserialize, Serialize)]
416pub struct ControlScope {
417    #[serde(rename = "ComplianceResourceIds")]
418    #[serde(default)]
419    #[serde(skip_serializing_if = "Option::is_none")]
420    pub compliance_resource_ids: Option<Vec<String>>,
421    #[serde(rename = "ComplianceResourceTypes")]
422    #[serde(default)]
423    #[serde(skip_serializing_if = "Option::is_none")]
424    pub compliance_resource_types: Option<Vec<String>>,
425    #[serde(rename = "Tags")]
426    #[serde(default)]
427    #[serde(skip_serializing_if = "Option::is_none")]
428    pub tags: Option<std::collections::HashMap<String, String>>,
429}
430
431#[derive(Debug, Clone, Default, Deserialize, Serialize)]
432pub struct CreateFrameworkOutput {
433    #[serde(rename = "FrameworkArn")]
434    #[serde(default)]
435    #[serde(skip_serializing_if = "Option::is_none")]
436    pub framework_arn: Option<String>,
437    #[serde(rename = "FrameworkName")]
438    #[serde(default)]
439    #[serde(skip_serializing_if = "Option::is_none")]
440    pub framework_name: Option<String>,
441}
442
443#[derive(Debug, Clone, Default, Deserialize, Serialize)]
444pub struct CreateLegalHoldInput {
445    #[serde(rename = "Description")]
446    #[serde(default)]
447    pub description: String,
448    #[serde(rename = "IdempotencyToken")]
449    #[serde(default)]
450    #[serde(skip_serializing_if = "Option::is_none")]
451    pub idempotency_token: Option<String>,
452    #[serde(rename = "RecoveryPointSelection")]
453    #[serde(default)]
454    #[serde(skip_serializing_if = "Option::is_none")]
455    pub recovery_point_selection: Option<RecoveryPointSelection>,
456    #[serde(rename = "Tags")]
457    #[serde(default)]
458    #[serde(skip_serializing_if = "Option::is_none")]
459    pub tags: Option<std::collections::HashMap<String, String>>,
460    #[serde(rename = "Title")]
461    #[serde(default)]
462    pub title: String,
463}
464
465#[derive(Debug, Clone, Default, Deserialize, Serialize)]
466pub struct RecoveryPointSelection {
467    #[serde(rename = "DateRange")]
468    #[serde(default)]
469    #[serde(skip_serializing_if = "Option::is_none")]
470    pub date_range: Option<DateRange>,
471    #[serde(rename = "ResourceIdentifiers")]
472    #[serde(default)]
473    #[serde(skip_serializing_if = "Option::is_none")]
474    pub resource_identifiers: Option<Vec<String>>,
475    #[serde(rename = "VaultNames")]
476    #[serde(default)]
477    #[serde(skip_serializing_if = "Option::is_none")]
478    pub vault_names: Option<Vec<String>>,
479}
480
481#[derive(Debug, Clone, Default, Deserialize, Serialize)]
482pub struct DateRange {
483    #[serde(rename = "FromDate")]
484    #[serde(default)]
485    pub from_date: f64,
486    #[serde(rename = "ToDate")]
487    #[serde(default)]
488    pub to_date: f64,
489}
490
491#[derive(Debug, Clone, Default, Deserialize, Serialize)]
492pub struct CreateLegalHoldOutput {
493    #[serde(rename = "CreationDate")]
494    #[serde(default)]
495    #[serde(skip_serializing_if = "Option::is_none")]
496    pub creation_date: Option<f64>,
497    #[serde(rename = "Description")]
498    #[serde(default)]
499    #[serde(skip_serializing_if = "Option::is_none")]
500    pub description: Option<String>,
501    #[serde(rename = "LegalHoldArn")]
502    #[serde(default)]
503    #[serde(skip_serializing_if = "Option::is_none")]
504    pub legal_hold_arn: Option<String>,
505    #[serde(rename = "LegalHoldId")]
506    #[serde(default)]
507    #[serde(skip_serializing_if = "Option::is_none")]
508    pub legal_hold_id: Option<String>,
509    #[serde(rename = "RecoveryPointSelection")]
510    #[serde(default)]
511    #[serde(skip_serializing_if = "Option::is_none")]
512    pub recovery_point_selection: Option<RecoveryPointSelection>,
513    #[serde(rename = "Status")]
514    #[serde(default)]
515    #[serde(skip_serializing_if = "Option::is_none")]
516    pub status: Option<String>,
517    #[serde(rename = "Title")]
518    #[serde(default)]
519    #[serde(skip_serializing_if = "Option::is_none")]
520    pub title: Option<String>,
521}
522
523#[derive(Debug, Clone, Default, Deserialize, Serialize)]
524pub struct CreateLogicallyAirGappedBackupVaultInput {
525    #[serde(rename = "BackupVaultName")]
526    #[serde(default)]
527    pub backup_vault_name: String,
528    #[serde(rename = "BackupVaultTags")]
529    #[serde(default)]
530    #[serde(skip_serializing_if = "Option::is_none")]
531    pub backup_vault_tags: Option<std::collections::HashMap<String, String>>,
532    #[serde(rename = "CreatorRequestId")]
533    #[serde(default)]
534    #[serde(skip_serializing_if = "Option::is_none")]
535    pub creator_request_id: Option<String>,
536    #[serde(rename = "EncryptionKeyArn")]
537    #[serde(default)]
538    #[serde(skip_serializing_if = "Option::is_none")]
539    pub encryption_key_arn: Option<String>,
540    #[serde(rename = "MaxRetentionDays")]
541    #[serde(default)]
542    pub max_retention_days: i64,
543    #[serde(rename = "MinRetentionDays")]
544    #[serde(default)]
545    pub min_retention_days: i64,
546}
547
548#[derive(Debug, Clone, Default, Deserialize, Serialize)]
549pub struct CreateLogicallyAirGappedBackupVaultOutput {
550    #[serde(rename = "BackupVaultArn")]
551    #[serde(default)]
552    #[serde(skip_serializing_if = "Option::is_none")]
553    pub backup_vault_arn: Option<String>,
554    #[serde(rename = "BackupVaultName")]
555    #[serde(default)]
556    #[serde(skip_serializing_if = "Option::is_none")]
557    pub backup_vault_name: Option<String>,
558    #[serde(rename = "CreationDate")]
559    #[serde(default)]
560    #[serde(skip_serializing_if = "Option::is_none")]
561    pub creation_date: Option<f64>,
562    #[serde(rename = "VaultState")]
563    #[serde(default)]
564    #[serde(skip_serializing_if = "Option::is_none")]
565    pub vault_state: Option<String>,
566}
567
568#[derive(Debug, Clone, Default, Deserialize, Serialize)]
569pub struct CreateReportPlanInput {
570    #[serde(rename = "IdempotencyToken")]
571    #[serde(default)]
572    #[serde(skip_serializing_if = "Option::is_none")]
573    pub idempotency_token: Option<String>,
574    #[serde(rename = "ReportDeliveryChannel")]
575    #[serde(default)]
576    pub report_delivery_channel: ReportDeliveryChannel,
577    #[serde(rename = "ReportPlanDescription")]
578    #[serde(default)]
579    #[serde(skip_serializing_if = "Option::is_none")]
580    pub report_plan_description: Option<String>,
581    #[serde(rename = "ReportPlanName")]
582    #[serde(default)]
583    pub report_plan_name: String,
584    #[serde(rename = "ReportPlanTags")]
585    #[serde(default)]
586    #[serde(skip_serializing_if = "Option::is_none")]
587    pub report_plan_tags: Option<std::collections::HashMap<String, String>>,
588    #[serde(rename = "ReportSetting")]
589    #[serde(default)]
590    pub report_setting: ReportSetting,
591}
592
593#[derive(Debug, Clone, Default, Deserialize, Serialize)]
594pub struct ReportDeliveryChannel {
595    #[serde(rename = "Formats")]
596    #[serde(default)]
597    #[serde(skip_serializing_if = "Option::is_none")]
598    pub formats: Option<Vec<String>>,
599    #[serde(rename = "S3BucketName")]
600    #[serde(default)]
601    pub s3_bucket_name: String,
602    #[serde(rename = "S3KeyPrefix")]
603    #[serde(default)]
604    #[serde(skip_serializing_if = "Option::is_none")]
605    pub s3_key_prefix: Option<String>,
606}
607
608#[derive(Debug, Clone, Default, Deserialize, Serialize)]
609pub struct ReportSetting {
610    #[serde(rename = "Accounts")]
611    #[serde(default)]
612    #[serde(skip_serializing_if = "Option::is_none")]
613    pub accounts: Option<Vec<String>>,
614    #[serde(rename = "FrameworkArns")]
615    #[serde(default)]
616    #[serde(skip_serializing_if = "Option::is_none")]
617    pub framework_arns: Option<Vec<String>>,
618    #[serde(rename = "NumberOfFrameworks")]
619    #[serde(default)]
620    #[serde(skip_serializing_if = "Option::is_none")]
621    pub number_of_frameworks: Option<i32>,
622    #[serde(rename = "OrganizationUnits")]
623    #[serde(default)]
624    #[serde(skip_serializing_if = "Option::is_none")]
625    pub organization_units: Option<Vec<String>>,
626    #[serde(rename = "Regions")]
627    #[serde(default)]
628    #[serde(skip_serializing_if = "Option::is_none")]
629    pub regions: Option<Vec<String>>,
630    #[serde(rename = "ReportTemplate")]
631    #[serde(default)]
632    pub report_template: String,
633}
634
635#[derive(Debug, Clone, Default, Deserialize, Serialize)]
636pub struct CreateReportPlanOutput {
637    #[serde(rename = "CreationTime")]
638    #[serde(default)]
639    #[serde(skip_serializing_if = "Option::is_none")]
640    pub creation_time: Option<f64>,
641    #[serde(rename = "ReportPlanArn")]
642    #[serde(default)]
643    #[serde(skip_serializing_if = "Option::is_none")]
644    pub report_plan_arn: Option<String>,
645    #[serde(rename = "ReportPlanName")]
646    #[serde(default)]
647    #[serde(skip_serializing_if = "Option::is_none")]
648    pub report_plan_name: Option<String>,
649}
650
651#[derive(Debug, Clone, Default, Deserialize, Serialize)]
652pub struct CreateRestoreAccessBackupVaultInput {
653    #[serde(rename = "BackupVaultName")]
654    #[serde(default)]
655    #[serde(skip_serializing_if = "Option::is_none")]
656    pub backup_vault_name: Option<String>,
657    #[serde(rename = "BackupVaultTags")]
658    #[serde(default)]
659    #[serde(skip_serializing_if = "Option::is_none")]
660    pub backup_vault_tags: Option<std::collections::HashMap<String, String>>,
661    #[serde(rename = "CreatorRequestId")]
662    #[serde(default)]
663    #[serde(skip_serializing_if = "Option::is_none")]
664    pub creator_request_id: Option<String>,
665    #[serde(rename = "RequesterComment")]
666    #[serde(default)]
667    #[serde(skip_serializing_if = "Option::is_none")]
668    pub requester_comment: Option<String>,
669    #[serde(rename = "SourceBackupVaultArn")]
670    #[serde(default)]
671    pub source_backup_vault_arn: String,
672}
673
674#[derive(Debug, Clone, Default, Deserialize, Serialize)]
675pub struct CreateRestoreAccessBackupVaultOutput {
676    #[serde(rename = "CreationDate")]
677    #[serde(default)]
678    #[serde(skip_serializing_if = "Option::is_none")]
679    pub creation_date: Option<f64>,
680    #[serde(rename = "RestoreAccessBackupVaultArn")]
681    #[serde(default)]
682    #[serde(skip_serializing_if = "Option::is_none")]
683    pub restore_access_backup_vault_arn: Option<String>,
684    #[serde(rename = "RestoreAccessBackupVaultName")]
685    #[serde(default)]
686    #[serde(skip_serializing_if = "Option::is_none")]
687    pub restore_access_backup_vault_name: Option<String>,
688    #[serde(rename = "VaultState")]
689    #[serde(default)]
690    #[serde(skip_serializing_if = "Option::is_none")]
691    pub vault_state: Option<String>,
692}
693
694#[derive(Debug, Clone, Default, Deserialize, Serialize)]
695pub struct CreateRestoreTestingPlanInput {
696    #[serde(rename = "CreatorRequestId")]
697    #[serde(default)]
698    #[serde(skip_serializing_if = "Option::is_none")]
699    pub creator_request_id: Option<String>,
700    #[serde(rename = "RestoreTestingPlan")]
701    #[serde(default)]
702    pub restore_testing_plan: RestoreTestingPlanForCreate,
703    #[serde(rename = "Tags")]
704    #[serde(default)]
705    #[serde(skip_serializing_if = "Option::is_none")]
706    pub tags: Option<std::collections::HashMap<String, String>>,
707}
708
709#[derive(Debug, Clone, Default, Deserialize, Serialize)]
710pub struct RestoreTestingPlanForCreate {
711    #[serde(rename = "RecoveryPointSelection")]
712    #[serde(default)]
713    pub recovery_point_selection: RestoreTestingRecoveryPointSelection,
714    #[serde(rename = "RestoreTestingPlanName")]
715    #[serde(default)]
716    pub restore_testing_plan_name: String,
717    #[serde(rename = "ScheduleExpression")]
718    #[serde(default)]
719    pub schedule_expression: String,
720    #[serde(rename = "ScheduleExpressionTimezone")]
721    #[serde(default)]
722    #[serde(skip_serializing_if = "Option::is_none")]
723    pub schedule_expression_timezone: Option<String>,
724    #[serde(rename = "StartWindowHours")]
725    #[serde(default)]
726    #[serde(skip_serializing_if = "Option::is_none")]
727    pub start_window_hours: Option<i32>,
728}
729
730#[derive(Debug, Clone, Default, Deserialize, Serialize)]
731pub struct RestoreTestingRecoveryPointSelection {
732    #[serde(rename = "Algorithm")]
733    #[serde(default)]
734    #[serde(skip_serializing_if = "Option::is_none")]
735    pub algorithm: Option<String>,
736    #[serde(rename = "ExcludeVaults")]
737    #[serde(default)]
738    #[serde(skip_serializing_if = "Option::is_none")]
739    pub exclude_vaults: Option<Vec<String>>,
740    #[serde(rename = "IncludeVaults")]
741    #[serde(default)]
742    #[serde(skip_serializing_if = "Option::is_none")]
743    pub include_vaults: Option<Vec<String>>,
744    #[serde(rename = "RecoveryPointTypes")]
745    #[serde(default)]
746    #[serde(skip_serializing_if = "Option::is_none")]
747    pub recovery_point_types: Option<Vec<String>>,
748    #[serde(rename = "SelectionWindowDays")]
749    #[serde(default)]
750    #[serde(skip_serializing_if = "Option::is_none")]
751    pub selection_window_days: Option<i32>,
752}
753
754#[derive(Debug, Clone, Default, Deserialize, Serialize)]
755pub struct CreateRestoreTestingPlanOutput {
756    #[serde(rename = "CreationTime")]
757    #[serde(default)]
758    #[serde(skip_serializing_if = "Option::is_none")]
759    pub creation_time: Option<f64>,
760    #[serde(rename = "RestoreTestingPlanArn")]
761    #[serde(default)]
762    #[serde(skip_serializing_if = "Option::is_none")]
763    pub restore_testing_plan_arn: Option<String>,
764    #[serde(rename = "RestoreTestingPlanName")]
765    #[serde(default)]
766    #[serde(skip_serializing_if = "Option::is_none")]
767    pub restore_testing_plan_name: Option<String>,
768}
769
770#[derive(Debug, Clone, Default, Deserialize, Serialize)]
771pub struct CreateRestoreTestingSelectionInput {
772    #[serde(rename = "CreatorRequestId")]
773    #[serde(default)]
774    #[serde(skip_serializing_if = "Option::is_none")]
775    pub creator_request_id: Option<String>,
776    #[serde(rename = "RestoreTestingPlanName")]
777    #[serde(default)]
778    pub restore_testing_plan_name: String,
779    #[serde(rename = "RestoreTestingSelection")]
780    #[serde(default)]
781    pub restore_testing_selection: RestoreTestingSelectionForCreate,
782}
783
784#[derive(Debug, Clone, Default, Deserialize, Serialize)]
785pub struct RestoreTestingSelectionForCreate {
786    #[serde(rename = "IamRoleArn")]
787    #[serde(default)]
788    pub iam_role_arn: String,
789    #[serde(rename = "ProtectedResourceArns")]
790    #[serde(default)]
791    #[serde(skip_serializing_if = "Option::is_none")]
792    pub protected_resource_arns: Option<Vec<String>>,
793    #[serde(rename = "ProtectedResourceConditions")]
794    #[serde(default)]
795    #[serde(skip_serializing_if = "Option::is_none")]
796    pub protected_resource_conditions: Option<ProtectedResourceConditions>,
797    #[serde(rename = "ProtectedResourceType")]
798    #[serde(default)]
799    pub protected_resource_type: String,
800    #[serde(rename = "RestoreMetadataOverrides")]
801    #[serde(default)]
802    #[serde(skip_serializing_if = "Option::is_none")]
803    pub restore_metadata_overrides: Option<std::collections::HashMap<String, String>>,
804    #[serde(rename = "RestoreTestingSelectionName")]
805    #[serde(default)]
806    pub restore_testing_selection_name: String,
807    #[serde(rename = "ValidationWindowHours")]
808    #[serde(default)]
809    #[serde(skip_serializing_if = "Option::is_none")]
810    pub validation_window_hours: Option<i32>,
811}
812
813#[derive(Debug, Clone, Default, Deserialize, Serialize)]
814pub struct ProtectedResourceConditions {
815    #[serde(rename = "StringEquals")]
816    #[serde(default)]
817    #[serde(skip_serializing_if = "Option::is_none")]
818    pub string_equals: Option<Vec<KeyValue>>,
819    #[serde(rename = "StringNotEquals")]
820    #[serde(default)]
821    #[serde(skip_serializing_if = "Option::is_none")]
822    pub string_not_equals: Option<Vec<KeyValue>>,
823}
824
825#[derive(Debug, Clone, Default, Deserialize, Serialize)]
826pub struct KeyValue {
827    #[serde(rename = "Key")]
828    #[serde(default)]
829    pub key: String,
830    #[serde(rename = "Value")]
831    #[serde(default)]
832    pub value: String,
833}
834
835#[derive(Debug, Clone, Default, Deserialize, Serialize)]
836pub struct CreateRestoreTestingSelectionOutput {
837    #[serde(rename = "CreationTime")]
838    #[serde(default)]
839    #[serde(skip_serializing_if = "Option::is_none")]
840    pub creation_time: Option<f64>,
841    #[serde(rename = "RestoreTestingPlanArn")]
842    #[serde(default)]
843    #[serde(skip_serializing_if = "Option::is_none")]
844    pub restore_testing_plan_arn: Option<String>,
845    #[serde(rename = "RestoreTestingPlanName")]
846    #[serde(default)]
847    #[serde(skip_serializing_if = "Option::is_none")]
848    pub restore_testing_plan_name: Option<String>,
849    #[serde(rename = "RestoreTestingSelectionName")]
850    #[serde(default)]
851    #[serde(skip_serializing_if = "Option::is_none")]
852    pub restore_testing_selection_name: Option<String>,
853}
854
855#[derive(Debug, Clone, Default, Deserialize, Serialize)]
856pub struct CreateTieringConfigurationInput {
857    #[serde(rename = "CreatorRequestId")]
858    #[serde(default)]
859    #[serde(skip_serializing_if = "Option::is_none")]
860    pub creator_request_id: Option<String>,
861    #[serde(rename = "TieringConfiguration")]
862    #[serde(default)]
863    pub tiering_configuration: TieringConfigurationInputForCreate,
864    #[serde(rename = "TieringConfigurationTags")]
865    #[serde(default)]
866    #[serde(skip_serializing_if = "Option::is_none")]
867    pub tiering_configuration_tags: Option<std::collections::HashMap<String, String>>,
868}
869
870#[derive(Debug, Clone, Default, Deserialize, Serialize)]
871pub struct TieringConfigurationInputForCreate {
872    #[serde(rename = "BackupVaultName")]
873    #[serde(default)]
874    pub backup_vault_name: String,
875    #[serde(rename = "ResourceSelection")]
876    #[serde(default)]
877    pub resource_selection: Vec<ResourceSelection>,
878    #[serde(rename = "TieringConfigurationName")]
879    #[serde(default)]
880    pub tiering_configuration_name: String,
881}
882
883#[derive(Debug, Clone, Default, Deserialize, Serialize)]
884pub struct ResourceSelection {
885    #[serde(rename = "ResourceType")]
886    #[serde(default)]
887    pub resource_type: String,
888    #[serde(rename = "Resources")]
889    #[serde(default)]
890    pub resources: Vec<String>,
891    #[serde(rename = "TieringDownSettingsInDays")]
892    #[serde(default)]
893    pub tiering_down_settings_in_days: i32,
894}
895
896#[derive(Debug, Clone, Default, Deserialize, Serialize)]
897pub struct CreateTieringConfigurationOutput {
898    #[serde(rename = "CreationTime")]
899    #[serde(default)]
900    #[serde(skip_serializing_if = "Option::is_none")]
901    pub creation_time: Option<f64>,
902    #[serde(rename = "TieringConfigurationArn")]
903    #[serde(default)]
904    #[serde(skip_serializing_if = "Option::is_none")]
905    pub tiering_configuration_arn: Option<String>,
906    #[serde(rename = "TieringConfigurationName")]
907    #[serde(default)]
908    #[serde(skip_serializing_if = "Option::is_none")]
909    pub tiering_configuration_name: Option<String>,
910}
911
912#[derive(Debug, Clone, Default, Deserialize, Serialize)]
913pub struct DeleteBackupPlanInput {
914    #[serde(rename = "BackupPlanId")]
915    #[serde(default)]
916    pub backup_plan_id: String,
917}
918
919#[derive(Debug, Clone, Default, Deserialize, Serialize)]
920pub struct DeleteBackupPlanOutput {
921    #[serde(rename = "BackupPlanArn")]
922    #[serde(default)]
923    #[serde(skip_serializing_if = "Option::is_none")]
924    pub backup_plan_arn: Option<String>,
925    #[serde(rename = "BackupPlanId")]
926    #[serde(default)]
927    #[serde(skip_serializing_if = "Option::is_none")]
928    pub backup_plan_id: Option<String>,
929    #[serde(rename = "DeletionDate")]
930    #[serde(default)]
931    #[serde(skip_serializing_if = "Option::is_none")]
932    pub deletion_date: Option<f64>,
933    #[serde(rename = "VersionId")]
934    #[serde(default)]
935    #[serde(skip_serializing_if = "Option::is_none")]
936    pub version_id: Option<String>,
937}
938
939#[derive(Debug, Clone, Default, Deserialize, Serialize)]
940pub struct DeleteBackupSelectionInput {
941    #[serde(rename = "BackupPlanId")]
942    #[serde(default)]
943    pub backup_plan_id: String,
944    #[serde(rename = "SelectionId")]
945    #[serde(default)]
946    pub selection_id: String,
947}
948
949#[derive(Debug, Clone, Default, Deserialize, Serialize)]
950pub struct DeleteBackupVaultAccessPolicyInput {
951    #[serde(rename = "BackupVaultName")]
952    #[serde(default)]
953    pub backup_vault_name: String,
954}
955
956#[derive(Debug, Clone, Default, Deserialize, Serialize)]
957pub struct DeleteBackupVaultInput {
958    #[serde(rename = "BackupVaultName")]
959    #[serde(default)]
960    pub backup_vault_name: String,
961}
962
963#[derive(Debug, Clone, Default, Deserialize, Serialize)]
964pub struct DeleteBackupVaultLockConfigurationInput {
965    #[serde(rename = "BackupVaultName")]
966    #[serde(default)]
967    pub backup_vault_name: String,
968}
969
970#[derive(Debug, Clone, Default, Deserialize, Serialize)]
971pub struct DeleteBackupVaultNotificationsInput {
972    #[serde(rename = "BackupVaultName")]
973    #[serde(default)]
974    pub backup_vault_name: String,
975}
976
977#[derive(Debug, Clone, Default, Deserialize, Serialize)]
978pub struct DeleteFrameworkInput {
979    #[serde(rename = "FrameworkName")]
980    #[serde(default)]
981    pub framework_name: String,
982}
983
984#[derive(Debug, Clone, Default, Deserialize, Serialize)]
985pub struct DeleteRecoveryPointInput {
986    #[serde(rename = "BackupVaultName")]
987    #[serde(default)]
988    pub backup_vault_name: String,
989    #[serde(rename = "RecoveryPointArn")]
990    #[serde(default)]
991    pub recovery_point_arn: String,
992}
993
994#[derive(Debug, Clone, Default, Deserialize, Serialize)]
995pub struct DeleteReportPlanInput {
996    #[serde(rename = "ReportPlanName")]
997    #[serde(default)]
998    pub report_plan_name: String,
999}
1000
1001#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1002pub struct DeleteRestoreTestingPlanInput {
1003    #[serde(rename = "RestoreTestingPlanName")]
1004    #[serde(default)]
1005    pub restore_testing_plan_name: String,
1006}
1007
1008#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1009pub struct DeleteRestoreTestingSelectionInput {
1010    #[serde(rename = "RestoreTestingPlanName")]
1011    #[serde(default)]
1012    pub restore_testing_plan_name: String,
1013    #[serde(rename = "RestoreTestingSelectionName")]
1014    #[serde(default)]
1015    pub restore_testing_selection_name: String,
1016}
1017
1018#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1019pub struct DeleteTieringConfigurationInput {
1020    #[serde(rename = "TieringConfigurationName")]
1021    #[serde(default)]
1022    pub tiering_configuration_name: String,
1023}
1024
1025#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1026pub struct DeleteTieringConfigurationOutput {}
1027
1028#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1029pub struct DescribeBackupJobInput {
1030    #[serde(rename = "BackupJobId")]
1031    #[serde(default)]
1032    pub backup_job_id: String,
1033}
1034
1035#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1036pub struct DescribeBackupJobOutput {
1037    #[serde(rename = "AccountId")]
1038    #[serde(default)]
1039    #[serde(skip_serializing_if = "Option::is_none")]
1040    pub account_id: Option<String>,
1041    #[serde(rename = "BackupJobId")]
1042    #[serde(default)]
1043    #[serde(skip_serializing_if = "Option::is_none")]
1044    pub backup_job_id: Option<String>,
1045    #[serde(rename = "BackupOptions")]
1046    #[serde(default)]
1047    #[serde(skip_serializing_if = "Option::is_none")]
1048    pub backup_options: Option<std::collections::HashMap<String, String>>,
1049    #[serde(rename = "BackupSizeInBytes")]
1050    #[serde(default)]
1051    #[serde(skip_serializing_if = "Option::is_none")]
1052    pub backup_size_in_bytes: Option<i64>,
1053    #[serde(rename = "BackupType")]
1054    #[serde(default)]
1055    #[serde(skip_serializing_if = "Option::is_none")]
1056    pub backup_type: Option<String>,
1057    #[serde(rename = "BackupVaultArn")]
1058    #[serde(default)]
1059    #[serde(skip_serializing_if = "Option::is_none")]
1060    pub backup_vault_arn: Option<String>,
1061    #[serde(rename = "BackupVaultName")]
1062    #[serde(default)]
1063    #[serde(skip_serializing_if = "Option::is_none")]
1064    pub backup_vault_name: Option<String>,
1065    #[serde(rename = "BytesTransferred")]
1066    #[serde(default)]
1067    #[serde(skip_serializing_if = "Option::is_none")]
1068    pub bytes_transferred: Option<i64>,
1069    #[serde(rename = "ChildJobsInState")]
1070    #[serde(default)]
1071    #[serde(skip_serializing_if = "Option::is_none")]
1072    pub child_jobs_in_state: Option<std::collections::HashMap<String, i64>>,
1073    #[serde(rename = "CompletionDate")]
1074    #[serde(default)]
1075    #[serde(skip_serializing_if = "Option::is_none")]
1076    pub completion_date: Option<f64>,
1077    #[serde(rename = "CreatedBy")]
1078    #[serde(default)]
1079    #[serde(skip_serializing_if = "Option::is_none")]
1080    pub created_by: Option<RecoveryPointCreator>,
1081    #[serde(rename = "CreationDate")]
1082    #[serde(default)]
1083    #[serde(skip_serializing_if = "Option::is_none")]
1084    pub creation_date: Option<f64>,
1085    #[serde(rename = "EncryptionKeyArn")]
1086    #[serde(default)]
1087    #[serde(skip_serializing_if = "Option::is_none")]
1088    pub encryption_key_arn: Option<String>,
1089    #[serde(rename = "ExpectedCompletionDate")]
1090    #[serde(default)]
1091    #[serde(skip_serializing_if = "Option::is_none")]
1092    pub expected_completion_date: Option<f64>,
1093    #[serde(rename = "IamRoleArn")]
1094    #[serde(default)]
1095    #[serde(skip_serializing_if = "Option::is_none")]
1096    pub iam_role_arn: Option<String>,
1097    #[serde(rename = "InitiationDate")]
1098    #[serde(default)]
1099    #[serde(skip_serializing_if = "Option::is_none")]
1100    pub initiation_date: Option<f64>,
1101    #[serde(rename = "IsEncrypted")]
1102    #[serde(default)]
1103    #[serde(skip_serializing_if = "Option::is_none")]
1104    pub is_encrypted: Option<bool>,
1105    #[serde(rename = "IsParent")]
1106    #[serde(default)]
1107    #[serde(skip_serializing_if = "Option::is_none")]
1108    pub is_parent: Option<bool>,
1109    #[serde(rename = "MessageCategory")]
1110    #[serde(default)]
1111    #[serde(skip_serializing_if = "Option::is_none")]
1112    pub message_category: Option<String>,
1113    #[serde(rename = "NumberOfChildJobs")]
1114    #[serde(default)]
1115    #[serde(skip_serializing_if = "Option::is_none")]
1116    pub number_of_child_jobs: Option<i64>,
1117    #[serde(rename = "ParentJobId")]
1118    #[serde(default)]
1119    #[serde(skip_serializing_if = "Option::is_none")]
1120    pub parent_job_id: Option<String>,
1121    #[serde(rename = "PercentDone")]
1122    #[serde(default)]
1123    #[serde(skip_serializing_if = "Option::is_none")]
1124    pub percent_done: Option<String>,
1125    #[serde(rename = "RecoveryPointArn")]
1126    #[serde(default)]
1127    #[serde(skip_serializing_if = "Option::is_none")]
1128    pub recovery_point_arn: Option<String>,
1129    #[serde(rename = "RecoveryPointLifecycle")]
1130    #[serde(default)]
1131    #[serde(skip_serializing_if = "Option::is_none")]
1132    pub recovery_point_lifecycle: Option<Lifecycle>,
1133    #[serde(rename = "ResourceArn")]
1134    #[serde(default)]
1135    #[serde(skip_serializing_if = "Option::is_none")]
1136    pub resource_arn: Option<String>,
1137    #[serde(rename = "ResourceName")]
1138    #[serde(default)]
1139    #[serde(skip_serializing_if = "Option::is_none")]
1140    pub resource_name: Option<String>,
1141    #[serde(rename = "ResourceType")]
1142    #[serde(default)]
1143    #[serde(skip_serializing_if = "Option::is_none")]
1144    pub resource_type: Option<String>,
1145    #[serde(rename = "StartBy")]
1146    #[serde(default)]
1147    #[serde(skip_serializing_if = "Option::is_none")]
1148    pub start_by: Option<f64>,
1149    #[serde(rename = "State")]
1150    #[serde(default)]
1151    #[serde(skip_serializing_if = "Option::is_none")]
1152    pub state: Option<String>,
1153    #[serde(rename = "StatusMessage")]
1154    #[serde(default)]
1155    #[serde(skip_serializing_if = "Option::is_none")]
1156    pub status_message: Option<String>,
1157    #[serde(rename = "VaultLockState")]
1158    #[serde(default)]
1159    #[serde(skip_serializing_if = "Option::is_none")]
1160    pub vault_lock_state: Option<String>,
1161    #[serde(rename = "VaultType")]
1162    #[serde(default)]
1163    #[serde(skip_serializing_if = "Option::is_none")]
1164    pub vault_type: Option<String>,
1165}
1166
1167#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1168pub struct RecoveryPointCreator {
1169    #[serde(rename = "BackupPlanArn")]
1170    #[serde(default)]
1171    #[serde(skip_serializing_if = "Option::is_none")]
1172    pub backup_plan_arn: Option<String>,
1173    #[serde(rename = "BackupPlanId")]
1174    #[serde(default)]
1175    #[serde(skip_serializing_if = "Option::is_none")]
1176    pub backup_plan_id: Option<String>,
1177    #[serde(rename = "BackupPlanName")]
1178    #[serde(default)]
1179    #[serde(skip_serializing_if = "Option::is_none")]
1180    pub backup_plan_name: Option<String>,
1181    #[serde(rename = "BackupPlanVersion")]
1182    #[serde(default)]
1183    #[serde(skip_serializing_if = "Option::is_none")]
1184    pub backup_plan_version: Option<String>,
1185    #[serde(rename = "BackupRuleCron")]
1186    #[serde(default)]
1187    #[serde(skip_serializing_if = "Option::is_none")]
1188    pub backup_rule_cron: Option<String>,
1189    #[serde(rename = "BackupRuleId")]
1190    #[serde(default)]
1191    #[serde(skip_serializing_if = "Option::is_none")]
1192    pub backup_rule_id: Option<String>,
1193    #[serde(rename = "BackupRuleName")]
1194    #[serde(default)]
1195    #[serde(skip_serializing_if = "Option::is_none")]
1196    pub backup_rule_name: Option<String>,
1197    #[serde(rename = "BackupRuleTimezone")]
1198    #[serde(default)]
1199    #[serde(skip_serializing_if = "Option::is_none")]
1200    pub backup_rule_timezone: Option<String>,
1201}
1202
1203#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1204pub struct DescribeBackupVaultInput {
1205    #[serde(rename = "BackupVaultAccountId")]
1206    #[serde(default)]
1207    #[serde(skip_serializing_if = "Option::is_none")]
1208    pub backup_vault_account_id: Option<String>,
1209    #[serde(rename = "BackupVaultName")]
1210    #[serde(default)]
1211    pub backup_vault_name: String,
1212}
1213
1214#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1215pub struct DescribeBackupVaultOutput {
1216    #[serde(rename = "BackupVaultArn")]
1217    #[serde(default)]
1218    #[serde(skip_serializing_if = "Option::is_none")]
1219    pub backup_vault_arn: Option<String>,
1220    #[serde(rename = "BackupVaultName")]
1221    #[serde(default)]
1222    #[serde(skip_serializing_if = "Option::is_none")]
1223    pub backup_vault_name: Option<String>,
1224    #[serde(rename = "CreationDate")]
1225    #[serde(default)]
1226    #[serde(skip_serializing_if = "Option::is_none")]
1227    pub creation_date: Option<f64>,
1228    #[serde(rename = "CreatorRequestId")]
1229    #[serde(default)]
1230    #[serde(skip_serializing_if = "Option::is_none")]
1231    pub creator_request_id: Option<String>,
1232    #[serde(rename = "EncryptionKeyArn")]
1233    #[serde(default)]
1234    #[serde(skip_serializing_if = "Option::is_none")]
1235    pub encryption_key_arn: Option<String>,
1236    #[serde(rename = "EncryptionKeyType")]
1237    #[serde(default)]
1238    #[serde(skip_serializing_if = "Option::is_none")]
1239    pub encryption_key_type: Option<String>,
1240    #[serde(rename = "LatestMpaApprovalTeamUpdate")]
1241    #[serde(default)]
1242    #[serde(skip_serializing_if = "Option::is_none")]
1243    pub latest_mpa_approval_team_update: Option<LatestMpaApprovalTeamUpdate>,
1244    #[serde(rename = "LockDate")]
1245    #[serde(default)]
1246    #[serde(skip_serializing_if = "Option::is_none")]
1247    pub lock_date: Option<f64>,
1248    #[serde(rename = "Locked")]
1249    #[serde(default)]
1250    #[serde(skip_serializing_if = "Option::is_none")]
1251    pub locked: Option<bool>,
1252    #[serde(rename = "MaxRetentionDays")]
1253    #[serde(default)]
1254    #[serde(skip_serializing_if = "Option::is_none")]
1255    pub max_retention_days: Option<i64>,
1256    #[serde(rename = "MinRetentionDays")]
1257    #[serde(default)]
1258    #[serde(skip_serializing_if = "Option::is_none")]
1259    pub min_retention_days: Option<i64>,
1260    #[serde(rename = "MpaApprovalTeamArn")]
1261    #[serde(default)]
1262    #[serde(skip_serializing_if = "Option::is_none")]
1263    pub mpa_approval_team_arn: Option<String>,
1264    #[serde(rename = "MpaSessionArn")]
1265    #[serde(default)]
1266    #[serde(skip_serializing_if = "Option::is_none")]
1267    pub mpa_session_arn: Option<String>,
1268    #[serde(rename = "NumberOfRecoveryPoints")]
1269    #[serde(default)]
1270    #[serde(skip_serializing_if = "Option::is_none")]
1271    pub number_of_recovery_points: Option<i64>,
1272    #[serde(rename = "SourceBackupVaultArn")]
1273    #[serde(default)]
1274    #[serde(skip_serializing_if = "Option::is_none")]
1275    pub source_backup_vault_arn: Option<String>,
1276    #[serde(rename = "VaultState")]
1277    #[serde(default)]
1278    #[serde(skip_serializing_if = "Option::is_none")]
1279    pub vault_state: Option<String>,
1280    #[serde(rename = "VaultType")]
1281    #[serde(default)]
1282    #[serde(skip_serializing_if = "Option::is_none")]
1283    pub vault_type: Option<String>,
1284}
1285
1286#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1287pub struct LatestMpaApprovalTeamUpdate {
1288    #[serde(rename = "ExpiryDate")]
1289    #[serde(default)]
1290    #[serde(skip_serializing_if = "Option::is_none")]
1291    pub expiry_date: Option<f64>,
1292    #[serde(rename = "InitiationDate")]
1293    #[serde(default)]
1294    #[serde(skip_serializing_if = "Option::is_none")]
1295    pub initiation_date: Option<f64>,
1296    #[serde(rename = "MpaSessionArn")]
1297    #[serde(default)]
1298    #[serde(skip_serializing_if = "Option::is_none")]
1299    pub mpa_session_arn: Option<String>,
1300    #[serde(rename = "Status")]
1301    #[serde(default)]
1302    #[serde(skip_serializing_if = "Option::is_none")]
1303    pub status: Option<String>,
1304    #[serde(rename = "StatusMessage")]
1305    #[serde(default)]
1306    #[serde(skip_serializing_if = "Option::is_none")]
1307    pub status_message: Option<String>,
1308}
1309
1310#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1311pub struct DescribeCopyJobInput {
1312    #[serde(rename = "CopyJobId")]
1313    #[serde(default)]
1314    pub copy_job_id: String,
1315}
1316
1317#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1318pub struct DescribeCopyJobOutput {
1319    #[serde(rename = "CopyJob")]
1320    #[serde(default)]
1321    #[serde(skip_serializing_if = "Option::is_none")]
1322    pub copy_job: Option<CopyJob>,
1323}
1324
1325#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1326pub struct CopyJob {
1327    #[serde(rename = "AccountId")]
1328    #[serde(default)]
1329    #[serde(skip_serializing_if = "Option::is_none")]
1330    pub account_id: Option<String>,
1331    #[serde(rename = "BackupSizeInBytes")]
1332    #[serde(default)]
1333    #[serde(skip_serializing_if = "Option::is_none")]
1334    pub backup_size_in_bytes: Option<i64>,
1335    #[serde(rename = "ChildJobsInState")]
1336    #[serde(default)]
1337    #[serde(skip_serializing_if = "Option::is_none")]
1338    pub child_jobs_in_state: Option<std::collections::HashMap<String, i64>>,
1339    #[serde(rename = "CompletionDate")]
1340    #[serde(default)]
1341    #[serde(skip_serializing_if = "Option::is_none")]
1342    pub completion_date: Option<f64>,
1343    #[serde(rename = "CompositeMemberIdentifier")]
1344    #[serde(default)]
1345    #[serde(skip_serializing_if = "Option::is_none")]
1346    pub composite_member_identifier: Option<String>,
1347    #[serde(rename = "CopyJobId")]
1348    #[serde(default)]
1349    #[serde(skip_serializing_if = "Option::is_none")]
1350    pub copy_job_id: Option<String>,
1351    #[serde(rename = "CreatedBy")]
1352    #[serde(default)]
1353    #[serde(skip_serializing_if = "Option::is_none")]
1354    pub created_by: Option<RecoveryPointCreator>,
1355    #[serde(rename = "CreatedByBackupJobId")]
1356    #[serde(default)]
1357    #[serde(skip_serializing_if = "Option::is_none")]
1358    pub created_by_backup_job_id: Option<String>,
1359    #[serde(rename = "CreationDate")]
1360    #[serde(default)]
1361    #[serde(skip_serializing_if = "Option::is_none")]
1362    pub creation_date: Option<f64>,
1363    #[serde(rename = "DestinationBackupVaultArn")]
1364    #[serde(default)]
1365    #[serde(skip_serializing_if = "Option::is_none")]
1366    pub destination_backup_vault_arn: Option<String>,
1367    #[serde(rename = "DestinationEncryptionKeyArn")]
1368    #[serde(default)]
1369    #[serde(skip_serializing_if = "Option::is_none")]
1370    pub destination_encryption_key_arn: Option<String>,
1371    #[serde(rename = "DestinationRecoveryPointArn")]
1372    #[serde(default)]
1373    #[serde(skip_serializing_if = "Option::is_none")]
1374    pub destination_recovery_point_arn: Option<String>,
1375    #[serde(rename = "DestinationRecoveryPointLifecycle")]
1376    #[serde(default)]
1377    #[serde(skip_serializing_if = "Option::is_none")]
1378    pub destination_recovery_point_lifecycle: Option<Lifecycle>,
1379    #[serde(rename = "DestinationVaultLockState")]
1380    #[serde(default)]
1381    #[serde(skip_serializing_if = "Option::is_none")]
1382    pub destination_vault_lock_state: Option<String>,
1383    #[serde(rename = "DestinationVaultType")]
1384    #[serde(default)]
1385    #[serde(skip_serializing_if = "Option::is_none")]
1386    pub destination_vault_type: Option<String>,
1387    #[serde(rename = "IamRoleArn")]
1388    #[serde(default)]
1389    #[serde(skip_serializing_if = "Option::is_none")]
1390    pub iam_role_arn: Option<String>,
1391    #[serde(rename = "IsParent")]
1392    #[serde(default)]
1393    #[serde(skip_serializing_if = "Option::is_none")]
1394    pub is_parent: Option<bool>,
1395    #[serde(rename = "MessageCategory")]
1396    #[serde(default)]
1397    #[serde(skip_serializing_if = "Option::is_none")]
1398    pub message_category: Option<String>,
1399    #[serde(rename = "NumberOfChildJobs")]
1400    #[serde(default)]
1401    #[serde(skip_serializing_if = "Option::is_none")]
1402    pub number_of_child_jobs: Option<i64>,
1403    #[serde(rename = "ParentJobId")]
1404    #[serde(default)]
1405    #[serde(skip_serializing_if = "Option::is_none")]
1406    pub parent_job_id: Option<String>,
1407    #[serde(rename = "ResourceArn")]
1408    #[serde(default)]
1409    #[serde(skip_serializing_if = "Option::is_none")]
1410    pub resource_arn: Option<String>,
1411    #[serde(rename = "ResourceName")]
1412    #[serde(default)]
1413    #[serde(skip_serializing_if = "Option::is_none")]
1414    pub resource_name: Option<String>,
1415    #[serde(rename = "ResourceType")]
1416    #[serde(default)]
1417    #[serde(skip_serializing_if = "Option::is_none")]
1418    pub resource_type: Option<String>,
1419    #[serde(rename = "SourceBackupVaultArn")]
1420    #[serde(default)]
1421    #[serde(skip_serializing_if = "Option::is_none")]
1422    pub source_backup_vault_arn: Option<String>,
1423    #[serde(rename = "SourceRecoveryPointArn")]
1424    #[serde(default)]
1425    #[serde(skip_serializing_if = "Option::is_none")]
1426    pub source_recovery_point_arn: Option<String>,
1427    #[serde(rename = "State")]
1428    #[serde(default)]
1429    #[serde(skip_serializing_if = "Option::is_none")]
1430    pub state: Option<String>,
1431    #[serde(rename = "StatusMessage")]
1432    #[serde(default)]
1433    #[serde(skip_serializing_if = "Option::is_none")]
1434    pub status_message: Option<String>,
1435}
1436
1437#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1438pub struct DescribeFrameworkInput {
1439    #[serde(rename = "FrameworkName")]
1440    #[serde(default)]
1441    pub framework_name: String,
1442}
1443
1444#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1445pub struct DescribeFrameworkOutput {
1446    #[serde(rename = "CreationTime")]
1447    #[serde(default)]
1448    #[serde(skip_serializing_if = "Option::is_none")]
1449    pub creation_time: Option<f64>,
1450    #[serde(rename = "DeploymentStatus")]
1451    #[serde(default)]
1452    #[serde(skip_serializing_if = "Option::is_none")]
1453    pub deployment_status: Option<String>,
1454    #[serde(rename = "FrameworkArn")]
1455    #[serde(default)]
1456    #[serde(skip_serializing_if = "Option::is_none")]
1457    pub framework_arn: Option<String>,
1458    #[serde(rename = "FrameworkControls")]
1459    #[serde(default)]
1460    #[serde(skip_serializing_if = "Option::is_none")]
1461    pub framework_controls: Option<Vec<FrameworkControl>>,
1462    #[serde(rename = "FrameworkDescription")]
1463    #[serde(default)]
1464    #[serde(skip_serializing_if = "Option::is_none")]
1465    pub framework_description: Option<String>,
1466    #[serde(rename = "FrameworkName")]
1467    #[serde(default)]
1468    #[serde(skip_serializing_if = "Option::is_none")]
1469    pub framework_name: Option<String>,
1470    #[serde(rename = "FrameworkStatus")]
1471    #[serde(default)]
1472    #[serde(skip_serializing_if = "Option::is_none")]
1473    pub framework_status: Option<String>,
1474    #[serde(rename = "IdempotencyToken")]
1475    #[serde(default)]
1476    #[serde(skip_serializing_if = "Option::is_none")]
1477    pub idempotency_token: Option<String>,
1478}
1479
1480#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1481pub struct DescribeGlobalSettingsInput {}
1482
1483#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1484pub struct DescribeGlobalSettingsOutput {
1485    #[serde(rename = "GlobalSettings")]
1486    #[serde(default)]
1487    #[serde(skip_serializing_if = "Option::is_none")]
1488    pub global_settings: Option<std::collections::HashMap<String, String>>,
1489    #[serde(rename = "LastUpdateTime")]
1490    #[serde(default)]
1491    #[serde(skip_serializing_if = "Option::is_none")]
1492    pub last_update_time: Option<f64>,
1493}
1494
1495#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1496pub struct DescribeProtectedResourceInput {
1497    #[serde(rename = "ResourceArn")]
1498    #[serde(default)]
1499    pub resource_arn: String,
1500}
1501
1502#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1503pub struct DescribeProtectedResourceOutput {
1504    #[serde(rename = "LastBackupTime")]
1505    #[serde(default)]
1506    #[serde(skip_serializing_if = "Option::is_none")]
1507    pub last_backup_time: Option<f64>,
1508    #[serde(rename = "LastBackupVaultArn")]
1509    #[serde(default)]
1510    #[serde(skip_serializing_if = "Option::is_none")]
1511    pub last_backup_vault_arn: Option<String>,
1512    #[serde(rename = "LastRecoveryPointArn")]
1513    #[serde(default)]
1514    #[serde(skip_serializing_if = "Option::is_none")]
1515    pub last_recovery_point_arn: Option<String>,
1516    #[serde(rename = "LatestRestoreExecutionTimeMinutes")]
1517    #[serde(default)]
1518    #[serde(skip_serializing_if = "Option::is_none")]
1519    pub latest_restore_execution_time_minutes: Option<i64>,
1520    #[serde(rename = "LatestRestoreJobCreationDate")]
1521    #[serde(default)]
1522    #[serde(skip_serializing_if = "Option::is_none")]
1523    pub latest_restore_job_creation_date: Option<f64>,
1524    #[serde(rename = "LatestRestoreRecoveryPointCreationDate")]
1525    #[serde(default)]
1526    #[serde(skip_serializing_if = "Option::is_none")]
1527    pub latest_restore_recovery_point_creation_date: Option<f64>,
1528    #[serde(rename = "ResourceArn")]
1529    #[serde(default)]
1530    #[serde(skip_serializing_if = "Option::is_none")]
1531    pub resource_arn: Option<String>,
1532    #[serde(rename = "ResourceName")]
1533    #[serde(default)]
1534    #[serde(skip_serializing_if = "Option::is_none")]
1535    pub resource_name: Option<String>,
1536    #[serde(rename = "ResourceType")]
1537    #[serde(default)]
1538    #[serde(skip_serializing_if = "Option::is_none")]
1539    pub resource_type: Option<String>,
1540}
1541
1542#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1543pub struct DescribeRecoveryPointInput {
1544    #[serde(rename = "BackupVaultAccountId")]
1545    #[serde(default)]
1546    #[serde(skip_serializing_if = "Option::is_none")]
1547    pub backup_vault_account_id: Option<String>,
1548    #[serde(rename = "BackupVaultName")]
1549    #[serde(default)]
1550    pub backup_vault_name: String,
1551    #[serde(rename = "RecoveryPointArn")]
1552    #[serde(default)]
1553    pub recovery_point_arn: String,
1554}
1555
1556#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1557pub struct DescribeRecoveryPointOutput {
1558    #[serde(rename = "BackupSizeInBytes")]
1559    #[serde(default)]
1560    #[serde(skip_serializing_if = "Option::is_none")]
1561    pub backup_size_in_bytes: Option<i64>,
1562    #[serde(rename = "BackupVaultArn")]
1563    #[serde(default)]
1564    #[serde(skip_serializing_if = "Option::is_none")]
1565    pub backup_vault_arn: Option<String>,
1566    #[serde(rename = "BackupVaultName")]
1567    #[serde(default)]
1568    #[serde(skip_serializing_if = "Option::is_none")]
1569    pub backup_vault_name: Option<String>,
1570    #[serde(rename = "CalculatedLifecycle")]
1571    #[serde(default)]
1572    #[serde(skip_serializing_if = "Option::is_none")]
1573    pub calculated_lifecycle: Option<CalculatedLifecycle>,
1574    #[serde(rename = "CompletionDate")]
1575    #[serde(default)]
1576    #[serde(skip_serializing_if = "Option::is_none")]
1577    pub completion_date: Option<f64>,
1578    #[serde(rename = "CompositeMemberIdentifier")]
1579    #[serde(default)]
1580    #[serde(skip_serializing_if = "Option::is_none")]
1581    pub composite_member_identifier: Option<String>,
1582    #[serde(rename = "CreatedBy")]
1583    #[serde(default)]
1584    #[serde(skip_serializing_if = "Option::is_none")]
1585    pub created_by: Option<RecoveryPointCreator>,
1586    #[serde(rename = "CreationDate")]
1587    #[serde(default)]
1588    #[serde(skip_serializing_if = "Option::is_none")]
1589    pub creation_date: Option<f64>,
1590    #[serde(rename = "EncryptionKeyArn")]
1591    #[serde(default)]
1592    #[serde(skip_serializing_if = "Option::is_none")]
1593    pub encryption_key_arn: Option<String>,
1594    #[serde(rename = "EncryptionKeyType")]
1595    #[serde(default)]
1596    #[serde(skip_serializing_if = "Option::is_none")]
1597    pub encryption_key_type: Option<String>,
1598    #[serde(rename = "IamRoleArn")]
1599    #[serde(default)]
1600    #[serde(skip_serializing_if = "Option::is_none")]
1601    pub iam_role_arn: Option<String>,
1602    #[serde(rename = "IndexStatus")]
1603    #[serde(default)]
1604    #[serde(skip_serializing_if = "Option::is_none")]
1605    pub index_status: Option<String>,
1606    #[serde(rename = "IndexStatusMessage")]
1607    #[serde(default)]
1608    #[serde(skip_serializing_if = "Option::is_none")]
1609    pub index_status_message: Option<String>,
1610    #[serde(rename = "InitiationDate")]
1611    #[serde(default)]
1612    #[serde(skip_serializing_if = "Option::is_none")]
1613    pub initiation_date: Option<f64>,
1614    #[serde(rename = "IsEncrypted")]
1615    #[serde(default)]
1616    #[serde(skip_serializing_if = "Option::is_none")]
1617    pub is_encrypted: Option<bool>,
1618    #[serde(rename = "IsParent")]
1619    #[serde(default)]
1620    #[serde(skip_serializing_if = "Option::is_none")]
1621    pub is_parent: Option<bool>,
1622    #[serde(rename = "LastRestoreTime")]
1623    #[serde(default)]
1624    #[serde(skip_serializing_if = "Option::is_none")]
1625    pub last_restore_time: Option<f64>,
1626    #[serde(rename = "Lifecycle")]
1627    #[serde(default)]
1628    #[serde(skip_serializing_if = "Option::is_none")]
1629    pub lifecycle: Option<Lifecycle>,
1630    #[serde(rename = "ParentRecoveryPointArn")]
1631    #[serde(default)]
1632    #[serde(skip_serializing_if = "Option::is_none")]
1633    pub parent_recovery_point_arn: Option<String>,
1634    #[serde(rename = "RecoveryPointArn")]
1635    #[serde(default)]
1636    #[serde(skip_serializing_if = "Option::is_none")]
1637    pub recovery_point_arn: Option<String>,
1638    #[serde(rename = "ResourceArn")]
1639    #[serde(default)]
1640    #[serde(skip_serializing_if = "Option::is_none")]
1641    pub resource_arn: Option<String>,
1642    #[serde(rename = "ResourceName")]
1643    #[serde(default)]
1644    #[serde(skip_serializing_if = "Option::is_none")]
1645    pub resource_name: Option<String>,
1646    #[serde(rename = "ResourceType")]
1647    #[serde(default)]
1648    #[serde(skip_serializing_if = "Option::is_none")]
1649    pub resource_type: Option<String>,
1650    #[serde(rename = "ScanResults")]
1651    #[serde(default)]
1652    #[serde(skip_serializing_if = "Option::is_none")]
1653    pub scan_results: Option<Vec<ScanResult>>,
1654    #[serde(rename = "SourceBackupVaultArn")]
1655    #[serde(default)]
1656    #[serde(skip_serializing_if = "Option::is_none")]
1657    pub source_backup_vault_arn: Option<String>,
1658    #[serde(rename = "Status")]
1659    #[serde(default)]
1660    #[serde(skip_serializing_if = "Option::is_none")]
1661    pub status: Option<String>,
1662    #[serde(rename = "StatusMessage")]
1663    #[serde(default)]
1664    #[serde(skip_serializing_if = "Option::is_none")]
1665    pub status_message: Option<String>,
1666    #[serde(rename = "StorageClass")]
1667    #[serde(default)]
1668    #[serde(skip_serializing_if = "Option::is_none")]
1669    pub storage_class: Option<String>,
1670    #[serde(rename = "VaultType")]
1671    #[serde(default)]
1672    #[serde(skip_serializing_if = "Option::is_none")]
1673    pub vault_type: Option<String>,
1674}
1675
1676#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1677pub struct CalculatedLifecycle {
1678    #[serde(rename = "DeleteAt")]
1679    #[serde(default)]
1680    #[serde(skip_serializing_if = "Option::is_none")]
1681    pub delete_at: Option<f64>,
1682    #[serde(rename = "MoveToColdStorageAt")]
1683    #[serde(default)]
1684    #[serde(skip_serializing_if = "Option::is_none")]
1685    pub move_to_cold_storage_at: Option<f64>,
1686}
1687
1688#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1689pub struct ScanResult {
1690    #[serde(rename = "Findings")]
1691    #[serde(default)]
1692    #[serde(skip_serializing_if = "Option::is_none")]
1693    pub findings: Option<Vec<String>>,
1694    #[serde(rename = "LastScanTimestamp")]
1695    #[serde(default)]
1696    #[serde(skip_serializing_if = "Option::is_none")]
1697    pub last_scan_timestamp: Option<f64>,
1698    #[serde(rename = "MalwareScanner")]
1699    #[serde(default)]
1700    #[serde(skip_serializing_if = "Option::is_none")]
1701    pub malware_scanner: Option<String>,
1702    #[serde(rename = "ScanJobState")]
1703    #[serde(default)]
1704    #[serde(skip_serializing_if = "Option::is_none")]
1705    pub scan_job_state: Option<String>,
1706}
1707
1708#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1709pub struct DescribeRegionSettingsInput {}
1710
1711#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1712pub struct DescribeRegionSettingsOutput {
1713    #[serde(rename = "ResourceTypeManagementPreference")]
1714    #[serde(default)]
1715    #[serde(skip_serializing_if = "Option::is_none")]
1716    pub resource_type_management_preference: Option<std::collections::HashMap<String, bool>>,
1717    #[serde(rename = "ResourceTypeOptInPreference")]
1718    #[serde(default)]
1719    #[serde(skip_serializing_if = "Option::is_none")]
1720    pub resource_type_opt_in_preference: Option<std::collections::HashMap<String, bool>>,
1721}
1722
1723#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1724pub struct DescribeReportJobInput {
1725    #[serde(rename = "ReportJobId")]
1726    #[serde(default)]
1727    pub report_job_id: String,
1728}
1729
1730#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1731pub struct DescribeReportJobOutput {
1732    #[serde(rename = "ReportJob")]
1733    #[serde(default)]
1734    #[serde(skip_serializing_if = "Option::is_none")]
1735    pub report_job: Option<ReportJob>,
1736}
1737
1738#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1739pub struct ReportJob {
1740    #[serde(rename = "CompletionTime")]
1741    #[serde(default)]
1742    #[serde(skip_serializing_if = "Option::is_none")]
1743    pub completion_time: Option<f64>,
1744    #[serde(rename = "CreationTime")]
1745    #[serde(default)]
1746    #[serde(skip_serializing_if = "Option::is_none")]
1747    pub creation_time: Option<f64>,
1748    #[serde(rename = "ReportDestination")]
1749    #[serde(default)]
1750    #[serde(skip_serializing_if = "Option::is_none")]
1751    pub report_destination: Option<ReportDestination>,
1752    #[serde(rename = "ReportJobId")]
1753    #[serde(default)]
1754    #[serde(skip_serializing_if = "Option::is_none")]
1755    pub report_job_id: Option<String>,
1756    #[serde(rename = "ReportPlanArn")]
1757    #[serde(default)]
1758    #[serde(skip_serializing_if = "Option::is_none")]
1759    pub report_plan_arn: Option<String>,
1760    #[serde(rename = "ReportTemplate")]
1761    #[serde(default)]
1762    #[serde(skip_serializing_if = "Option::is_none")]
1763    pub report_template: Option<String>,
1764    #[serde(rename = "Status")]
1765    #[serde(default)]
1766    #[serde(skip_serializing_if = "Option::is_none")]
1767    pub status: Option<String>,
1768    #[serde(rename = "StatusMessage")]
1769    #[serde(default)]
1770    #[serde(skip_serializing_if = "Option::is_none")]
1771    pub status_message: Option<String>,
1772}
1773
1774#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1775pub struct ReportDestination {
1776    #[serde(rename = "S3BucketName")]
1777    #[serde(default)]
1778    #[serde(skip_serializing_if = "Option::is_none")]
1779    pub s3_bucket_name: Option<String>,
1780    #[serde(rename = "S3Keys")]
1781    #[serde(default)]
1782    #[serde(skip_serializing_if = "Option::is_none")]
1783    pub s3_keys: Option<Vec<String>>,
1784}
1785
1786#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1787pub struct DescribeReportPlanInput {
1788    #[serde(rename = "ReportPlanName")]
1789    #[serde(default)]
1790    pub report_plan_name: String,
1791}
1792
1793#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1794pub struct DescribeReportPlanOutput {
1795    #[serde(rename = "ReportPlan")]
1796    #[serde(default)]
1797    #[serde(skip_serializing_if = "Option::is_none")]
1798    pub report_plan: Option<ReportPlan>,
1799}
1800
1801#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1802pub struct ReportPlan {
1803    #[serde(rename = "CreationTime")]
1804    #[serde(default)]
1805    #[serde(skip_serializing_if = "Option::is_none")]
1806    pub creation_time: Option<f64>,
1807    #[serde(rename = "DeploymentStatus")]
1808    #[serde(default)]
1809    #[serde(skip_serializing_if = "Option::is_none")]
1810    pub deployment_status: Option<String>,
1811    #[serde(rename = "LastAttemptedExecutionTime")]
1812    #[serde(default)]
1813    #[serde(skip_serializing_if = "Option::is_none")]
1814    pub last_attempted_execution_time: Option<f64>,
1815    #[serde(rename = "LastSuccessfulExecutionTime")]
1816    #[serde(default)]
1817    #[serde(skip_serializing_if = "Option::is_none")]
1818    pub last_successful_execution_time: Option<f64>,
1819    #[serde(rename = "ReportDeliveryChannel")]
1820    #[serde(default)]
1821    #[serde(skip_serializing_if = "Option::is_none")]
1822    pub report_delivery_channel: Option<ReportDeliveryChannel>,
1823    #[serde(rename = "ReportPlanArn")]
1824    #[serde(default)]
1825    #[serde(skip_serializing_if = "Option::is_none")]
1826    pub report_plan_arn: Option<String>,
1827    #[serde(rename = "ReportPlanDescription")]
1828    #[serde(default)]
1829    #[serde(skip_serializing_if = "Option::is_none")]
1830    pub report_plan_description: Option<String>,
1831    #[serde(rename = "ReportPlanName")]
1832    #[serde(default)]
1833    #[serde(skip_serializing_if = "Option::is_none")]
1834    pub report_plan_name: Option<String>,
1835    #[serde(rename = "ReportSetting")]
1836    #[serde(default)]
1837    #[serde(skip_serializing_if = "Option::is_none")]
1838    pub report_setting: Option<ReportSetting>,
1839}
1840
1841#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1842pub struct DescribeRestoreJobInput {
1843    #[serde(rename = "RestoreJobId")]
1844    #[serde(default)]
1845    pub restore_job_id: String,
1846}
1847
1848#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1849pub struct DescribeRestoreJobOutput {
1850    #[serde(rename = "AccountId")]
1851    #[serde(default)]
1852    #[serde(skip_serializing_if = "Option::is_none")]
1853    pub account_id: Option<String>,
1854    #[serde(rename = "BackupSizeInBytes")]
1855    #[serde(default)]
1856    #[serde(skip_serializing_if = "Option::is_none")]
1857    pub backup_size_in_bytes: Option<i64>,
1858    #[serde(rename = "BackupVaultArn")]
1859    #[serde(default)]
1860    #[serde(skip_serializing_if = "Option::is_none")]
1861    pub backup_vault_arn: Option<String>,
1862    #[serde(rename = "CompletionDate")]
1863    #[serde(default)]
1864    #[serde(skip_serializing_if = "Option::is_none")]
1865    pub completion_date: Option<f64>,
1866    #[serde(rename = "CreatedBy")]
1867    #[serde(default)]
1868    #[serde(skip_serializing_if = "Option::is_none")]
1869    pub created_by: Option<RestoreJobCreator>,
1870    #[serde(rename = "CreatedResourceArn")]
1871    #[serde(default)]
1872    #[serde(skip_serializing_if = "Option::is_none")]
1873    pub created_resource_arn: Option<String>,
1874    #[serde(rename = "CreationDate")]
1875    #[serde(default)]
1876    #[serde(skip_serializing_if = "Option::is_none")]
1877    pub creation_date: Option<f64>,
1878    #[serde(rename = "DeletionStatus")]
1879    #[serde(default)]
1880    #[serde(skip_serializing_if = "Option::is_none")]
1881    pub deletion_status: Option<String>,
1882    #[serde(rename = "DeletionStatusMessage")]
1883    #[serde(default)]
1884    #[serde(skip_serializing_if = "Option::is_none")]
1885    pub deletion_status_message: Option<String>,
1886    #[serde(rename = "ExpectedCompletionTimeMinutes")]
1887    #[serde(default)]
1888    #[serde(skip_serializing_if = "Option::is_none")]
1889    pub expected_completion_time_minutes: Option<i64>,
1890    #[serde(rename = "IamRoleArn")]
1891    #[serde(default)]
1892    #[serde(skip_serializing_if = "Option::is_none")]
1893    pub iam_role_arn: Option<String>,
1894    #[serde(rename = "IsParent")]
1895    #[serde(default)]
1896    #[serde(skip_serializing_if = "Option::is_none")]
1897    pub is_parent: Option<bool>,
1898    #[serde(rename = "ParentJobId")]
1899    #[serde(default)]
1900    #[serde(skip_serializing_if = "Option::is_none")]
1901    pub parent_job_id: Option<String>,
1902    #[serde(rename = "PercentDone")]
1903    #[serde(default)]
1904    #[serde(skip_serializing_if = "Option::is_none")]
1905    pub percent_done: Option<String>,
1906    #[serde(rename = "RecoveryPointArn")]
1907    #[serde(default)]
1908    #[serde(skip_serializing_if = "Option::is_none")]
1909    pub recovery_point_arn: Option<String>,
1910    #[serde(rename = "RecoveryPointCreationDate")]
1911    #[serde(default)]
1912    #[serde(skip_serializing_if = "Option::is_none")]
1913    pub recovery_point_creation_date: Option<f64>,
1914    #[serde(rename = "ResourceType")]
1915    #[serde(default)]
1916    #[serde(skip_serializing_if = "Option::is_none")]
1917    pub resource_type: Option<String>,
1918    #[serde(rename = "RestoreJobId")]
1919    #[serde(default)]
1920    #[serde(skip_serializing_if = "Option::is_none")]
1921    pub restore_job_id: Option<String>,
1922    #[serde(rename = "SourceResourceArn")]
1923    #[serde(default)]
1924    #[serde(skip_serializing_if = "Option::is_none")]
1925    pub source_resource_arn: Option<String>,
1926    #[serde(rename = "Status")]
1927    #[serde(default)]
1928    #[serde(skip_serializing_if = "Option::is_none")]
1929    pub status: Option<String>,
1930    #[serde(rename = "StatusMessage")]
1931    #[serde(default)]
1932    #[serde(skip_serializing_if = "Option::is_none")]
1933    pub status_message: Option<String>,
1934    #[serde(rename = "ValidationStatus")]
1935    #[serde(default)]
1936    #[serde(skip_serializing_if = "Option::is_none")]
1937    pub validation_status: Option<String>,
1938    #[serde(rename = "ValidationStatusMessage")]
1939    #[serde(default)]
1940    #[serde(skip_serializing_if = "Option::is_none")]
1941    pub validation_status_message: Option<String>,
1942}
1943
1944#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1945pub struct RestoreJobCreator {
1946    #[serde(rename = "RestoreTestingPlanArn")]
1947    #[serde(default)]
1948    #[serde(skip_serializing_if = "Option::is_none")]
1949    pub restore_testing_plan_arn: Option<String>,
1950}
1951
1952#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1953pub struct DescribeScanJobInput {
1954    #[serde(rename = "ScanJobId")]
1955    #[serde(default)]
1956    pub scan_job_id: String,
1957}
1958
1959#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1960pub struct DescribeScanJobOutput {
1961    #[serde(rename = "AccountId")]
1962    #[serde(default)]
1963    #[serde(skip_serializing_if = "Option::is_none")]
1964    pub account_id: Option<String>,
1965    #[serde(rename = "BackupVaultArn")]
1966    #[serde(default)]
1967    #[serde(skip_serializing_if = "Option::is_none")]
1968    pub backup_vault_arn: Option<String>,
1969    #[serde(rename = "BackupVaultName")]
1970    #[serde(default)]
1971    #[serde(skip_serializing_if = "Option::is_none")]
1972    pub backup_vault_name: Option<String>,
1973    #[serde(rename = "CompletionDate")]
1974    #[serde(default)]
1975    #[serde(skip_serializing_if = "Option::is_none")]
1976    pub completion_date: Option<f64>,
1977    #[serde(rename = "CreatedBy")]
1978    #[serde(default)]
1979    #[serde(skip_serializing_if = "Option::is_none")]
1980    pub created_by: Option<ScanJobCreator>,
1981    #[serde(rename = "CreationDate")]
1982    #[serde(default)]
1983    #[serde(skip_serializing_if = "Option::is_none")]
1984    pub creation_date: Option<f64>,
1985    #[serde(rename = "IamRoleArn")]
1986    #[serde(default)]
1987    #[serde(skip_serializing_if = "Option::is_none")]
1988    pub iam_role_arn: Option<String>,
1989    #[serde(rename = "MalwareScanner")]
1990    #[serde(default)]
1991    #[serde(skip_serializing_if = "Option::is_none")]
1992    pub malware_scanner: Option<String>,
1993    #[serde(rename = "RecoveryPointArn")]
1994    #[serde(default)]
1995    #[serde(skip_serializing_if = "Option::is_none")]
1996    pub recovery_point_arn: Option<String>,
1997    #[serde(rename = "ResourceArn")]
1998    #[serde(default)]
1999    #[serde(skip_serializing_if = "Option::is_none")]
2000    pub resource_arn: Option<String>,
2001    #[serde(rename = "ResourceName")]
2002    #[serde(default)]
2003    #[serde(skip_serializing_if = "Option::is_none")]
2004    pub resource_name: Option<String>,
2005    #[serde(rename = "ResourceType")]
2006    #[serde(default)]
2007    #[serde(skip_serializing_if = "Option::is_none")]
2008    pub resource_type: Option<String>,
2009    #[serde(rename = "ScanBaseRecoveryPointArn")]
2010    #[serde(default)]
2011    #[serde(skip_serializing_if = "Option::is_none")]
2012    pub scan_base_recovery_point_arn: Option<String>,
2013    #[serde(rename = "ScanId")]
2014    #[serde(default)]
2015    #[serde(skip_serializing_if = "Option::is_none")]
2016    pub scan_id: Option<String>,
2017    #[serde(rename = "ScanJobId")]
2018    #[serde(default)]
2019    #[serde(skip_serializing_if = "Option::is_none")]
2020    pub scan_job_id: Option<String>,
2021    #[serde(rename = "ScanMode")]
2022    #[serde(default)]
2023    #[serde(skip_serializing_if = "Option::is_none")]
2024    pub scan_mode: Option<String>,
2025    #[serde(rename = "ScanResult")]
2026    #[serde(default)]
2027    #[serde(skip_serializing_if = "Option::is_none")]
2028    pub scan_result: Option<ScanResultInfo>,
2029    #[serde(rename = "ScannerRoleArn")]
2030    #[serde(default)]
2031    #[serde(skip_serializing_if = "Option::is_none")]
2032    pub scanner_role_arn: Option<String>,
2033    #[serde(rename = "State")]
2034    #[serde(default)]
2035    #[serde(skip_serializing_if = "Option::is_none")]
2036    pub state: Option<String>,
2037    #[serde(rename = "StatusMessage")]
2038    #[serde(default)]
2039    #[serde(skip_serializing_if = "Option::is_none")]
2040    pub status_message: Option<String>,
2041}
2042
2043#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2044pub struct ScanJobCreator {
2045    #[serde(rename = "BackupPlanArn")]
2046    #[serde(default)]
2047    #[serde(skip_serializing_if = "Option::is_none")]
2048    pub backup_plan_arn: Option<String>,
2049    #[serde(rename = "BackupPlanId")]
2050    #[serde(default)]
2051    #[serde(skip_serializing_if = "Option::is_none")]
2052    pub backup_plan_id: Option<String>,
2053    #[serde(rename = "BackupPlanVersion")]
2054    #[serde(default)]
2055    #[serde(skip_serializing_if = "Option::is_none")]
2056    pub backup_plan_version: Option<String>,
2057    #[serde(rename = "BackupRuleId")]
2058    #[serde(default)]
2059    #[serde(skip_serializing_if = "Option::is_none")]
2060    pub backup_rule_id: Option<String>,
2061}
2062
2063#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2064pub struct ScanResultInfo {
2065    #[serde(rename = "ScanResultStatus")]
2066    #[serde(default)]
2067    #[serde(skip_serializing_if = "Option::is_none")]
2068    pub scan_result_status: Option<String>,
2069}
2070
2071#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2072pub struct DisassociateBackupVaultMpaApprovalTeamInput {
2073    #[serde(rename = "BackupVaultName")]
2074    #[serde(default)]
2075    pub backup_vault_name: String,
2076    #[serde(rename = "RequesterComment")]
2077    #[serde(default)]
2078    #[serde(skip_serializing_if = "Option::is_none")]
2079    pub requester_comment: Option<String>,
2080}
2081
2082#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2083pub struct DisassociateRecoveryPointFromParentInput {
2084    #[serde(rename = "BackupVaultName")]
2085    #[serde(default)]
2086    pub backup_vault_name: String,
2087    #[serde(rename = "RecoveryPointArn")]
2088    #[serde(default)]
2089    pub recovery_point_arn: String,
2090}
2091
2092#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2093pub struct DisassociateRecoveryPointInput {
2094    #[serde(rename = "BackupVaultName")]
2095    #[serde(default)]
2096    pub backup_vault_name: String,
2097    #[serde(rename = "RecoveryPointArn")]
2098    #[serde(default)]
2099    pub recovery_point_arn: String,
2100}
2101
2102#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2103pub struct ExportBackupPlanTemplateInput {
2104    #[serde(rename = "BackupPlanId")]
2105    #[serde(default)]
2106    pub backup_plan_id: String,
2107}
2108
2109#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2110pub struct ExportBackupPlanTemplateOutput {
2111    #[serde(rename = "BackupPlanTemplateJson")]
2112    #[serde(default)]
2113    #[serde(skip_serializing_if = "Option::is_none")]
2114    pub backup_plan_template_json: Option<String>,
2115}
2116
2117#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2118pub struct GetBackupPlanFromJSONInput {
2119    #[serde(rename = "BackupPlanTemplateJson")]
2120    #[serde(default)]
2121    pub backup_plan_template_json: String,
2122}
2123
2124#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2125pub struct GetBackupPlanFromJSONOutput {
2126    #[serde(rename = "BackupPlan")]
2127    #[serde(default)]
2128    #[serde(skip_serializing_if = "Option::is_none")]
2129    pub backup_plan: Option<BackupPlan>,
2130}
2131
2132#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2133pub struct BackupPlan {
2134    #[serde(rename = "AdvancedBackupSettings")]
2135    #[serde(default)]
2136    #[serde(skip_serializing_if = "Option::is_none")]
2137    pub advanced_backup_settings: Option<Vec<AdvancedBackupSetting>>,
2138    #[serde(rename = "BackupPlanName")]
2139    #[serde(default)]
2140    #[serde(skip_serializing_if = "Option::is_none")]
2141    pub backup_plan_name: Option<String>,
2142    #[serde(rename = "Rules")]
2143    #[serde(default)]
2144    #[serde(skip_serializing_if = "Option::is_none")]
2145    pub rules: Option<Vec<BackupRule>>,
2146    #[serde(rename = "ScanSettings")]
2147    #[serde(default)]
2148    #[serde(skip_serializing_if = "Option::is_none")]
2149    pub scan_settings: Option<Vec<ScanSetting>>,
2150}
2151
2152#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2153pub struct BackupRule {
2154    #[serde(rename = "CompletionWindowMinutes")]
2155    #[serde(default)]
2156    #[serde(skip_serializing_if = "Option::is_none")]
2157    pub completion_window_minutes: Option<i64>,
2158    #[serde(rename = "CopyActions")]
2159    #[serde(default)]
2160    #[serde(skip_serializing_if = "Option::is_none")]
2161    pub copy_actions: Option<Vec<CopyAction>>,
2162    #[serde(rename = "EnableContinuousBackup")]
2163    #[serde(default)]
2164    #[serde(skip_serializing_if = "Option::is_none")]
2165    pub enable_continuous_backup: Option<bool>,
2166    #[serde(rename = "IndexActions")]
2167    #[serde(default)]
2168    #[serde(skip_serializing_if = "Option::is_none")]
2169    pub index_actions: Option<Vec<IndexAction>>,
2170    #[serde(rename = "Lifecycle")]
2171    #[serde(default)]
2172    #[serde(skip_serializing_if = "Option::is_none")]
2173    pub lifecycle: Option<Lifecycle>,
2174    #[serde(rename = "RecoveryPointTags")]
2175    #[serde(default)]
2176    #[serde(skip_serializing_if = "Option::is_none")]
2177    pub recovery_point_tags: Option<std::collections::HashMap<String, String>>,
2178    #[serde(rename = "RuleId")]
2179    #[serde(default)]
2180    #[serde(skip_serializing_if = "Option::is_none")]
2181    pub rule_id: Option<String>,
2182    #[serde(rename = "RuleName")]
2183    #[serde(default)]
2184    #[serde(skip_serializing_if = "Option::is_none")]
2185    pub rule_name: Option<String>,
2186    #[serde(rename = "ScanActions")]
2187    #[serde(default)]
2188    #[serde(skip_serializing_if = "Option::is_none")]
2189    pub scan_actions: Option<Vec<ScanAction>>,
2190    #[serde(rename = "ScheduleExpression")]
2191    #[serde(default)]
2192    #[serde(skip_serializing_if = "Option::is_none")]
2193    pub schedule_expression: Option<String>,
2194    #[serde(rename = "ScheduleExpressionTimezone")]
2195    #[serde(default)]
2196    #[serde(skip_serializing_if = "Option::is_none")]
2197    pub schedule_expression_timezone: Option<String>,
2198    #[serde(rename = "StartWindowMinutes")]
2199    #[serde(default)]
2200    #[serde(skip_serializing_if = "Option::is_none")]
2201    pub start_window_minutes: Option<i64>,
2202    #[serde(rename = "TargetBackupVaultName")]
2203    #[serde(default)]
2204    #[serde(skip_serializing_if = "Option::is_none")]
2205    pub target_backup_vault_name: Option<String>,
2206    #[serde(rename = "TargetLogicallyAirGappedBackupVaultArn")]
2207    #[serde(default)]
2208    #[serde(skip_serializing_if = "Option::is_none")]
2209    pub target_logically_air_gapped_backup_vault_arn: Option<String>,
2210}
2211
2212#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2213pub struct GetBackupPlanFromTemplateInput {
2214    #[serde(rename = "BackupPlanTemplateId")]
2215    #[serde(default)]
2216    pub backup_plan_template_id: String,
2217}
2218
2219#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2220pub struct GetBackupPlanFromTemplateOutput {
2221    #[serde(rename = "BackupPlanDocument")]
2222    #[serde(default)]
2223    #[serde(skip_serializing_if = "Option::is_none")]
2224    pub backup_plan_document: Option<BackupPlan>,
2225}
2226
2227#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2228pub struct GetBackupPlanInput {
2229    #[serde(rename = "BackupPlanId")]
2230    #[serde(default)]
2231    pub backup_plan_id: String,
2232    #[serde(rename = "MaxScheduledRunsPreview")]
2233    #[serde(default)]
2234    #[serde(skip_serializing_if = "Option::is_none")]
2235    pub max_scheduled_runs_preview: Option<i32>,
2236    #[serde(rename = "VersionId")]
2237    #[serde(default)]
2238    #[serde(skip_serializing_if = "Option::is_none")]
2239    pub version_id: Option<String>,
2240}
2241
2242#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2243pub struct GetBackupPlanOutput {
2244    #[serde(rename = "AdvancedBackupSettings")]
2245    #[serde(default)]
2246    #[serde(skip_serializing_if = "Option::is_none")]
2247    pub advanced_backup_settings: Option<Vec<AdvancedBackupSetting>>,
2248    #[serde(rename = "BackupPlan")]
2249    #[serde(default)]
2250    #[serde(skip_serializing_if = "Option::is_none")]
2251    pub backup_plan: Option<BackupPlan>,
2252    #[serde(rename = "BackupPlanArn")]
2253    #[serde(default)]
2254    #[serde(skip_serializing_if = "Option::is_none")]
2255    pub backup_plan_arn: Option<String>,
2256    #[serde(rename = "BackupPlanId")]
2257    #[serde(default)]
2258    #[serde(skip_serializing_if = "Option::is_none")]
2259    pub backup_plan_id: Option<String>,
2260    #[serde(rename = "CreationDate")]
2261    #[serde(default)]
2262    #[serde(skip_serializing_if = "Option::is_none")]
2263    pub creation_date: Option<f64>,
2264    #[serde(rename = "CreatorRequestId")]
2265    #[serde(default)]
2266    #[serde(skip_serializing_if = "Option::is_none")]
2267    pub creator_request_id: Option<String>,
2268    #[serde(rename = "DeletionDate")]
2269    #[serde(default)]
2270    #[serde(skip_serializing_if = "Option::is_none")]
2271    pub deletion_date: Option<f64>,
2272    #[serde(rename = "LastExecutionDate")]
2273    #[serde(default)]
2274    #[serde(skip_serializing_if = "Option::is_none")]
2275    pub last_execution_date: Option<f64>,
2276    #[serde(rename = "ScheduledRunsPreview")]
2277    #[serde(default)]
2278    #[serde(skip_serializing_if = "Option::is_none")]
2279    pub scheduled_runs_preview: Option<Vec<ScheduledPlanExecutionMember>>,
2280    #[serde(rename = "VersionId")]
2281    #[serde(default)]
2282    #[serde(skip_serializing_if = "Option::is_none")]
2283    pub version_id: Option<String>,
2284}
2285
2286#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2287pub struct ScheduledPlanExecutionMember {
2288    #[serde(rename = "ExecutionTime")]
2289    #[serde(default)]
2290    #[serde(skip_serializing_if = "Option::is_none")]
2291    pub execution_time: Option<f64>,
2292    #[serde(rename = "RuleExecutionType")]
2293    #[serde(default)]
2294    #[serde(skip_serializing_if = "Option::is_none")]
2295    pub rule_execution_type: Option<String>,
2296    #[serde(rename = "RuleId")]
2297    #[serde(default)]
2298    #[serde(skip_serializing_if = "Option::is_none")]
2299    pub rule_id: Option<String>,
2300}
2301
2302#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2303pub struct GetBackupSelectionInput {
2304    #[serde(rename = "BackupPlanId")]
2305    #[serde(default)]
2306    pub backup_plan_id: String,
2307    #[serde(rename = "SelectionId")]
2308    #[serde(default)]
2309    pub selection_id: String,
2310}
2311
2312#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2313pub struct GetBackupSelectionOutput {
2314    #[serde(rename = "BackupPlanId")]
2315    #[serde(default)]
2316    #[serde(skip_serializing_if = "Option::is_none")]
2317    pub backup_plan_id: Option<String>,
2318    #[serde(rename = "BackupSelection")]
2319    #[serde(default)]
2320    #[serde(skip_serializing_if = "Option::is_none")]
2321    pub backup_selection: Option<BackupSelection>,
2322    #[serde(rename = "CreationDate")]
2323    #[serde(default)]
2324    #[serde(skip_serializing_if = "Option::is_none")]
2325    pub creation_date: Option<f64>,
2326    #[serde(rename = "CreatorRequestId")]
2327    #[serde(default)]
2328    #[serde(skip_serializing_if = "Option::is_none")]
2329    pub creator_request_id: Option<String>,
2330    #[serde(rename = "SelectionId")]
2331    #[serde(default)]
2332    #[serde(skip_serializing_if = "Option::is_none")]
2333    pub selection_id: Option<String>,
2334}
2335
2336#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2337pub struct GetBackupVaultAccessPolicyInput {
2338    #[serde(rename = "BackupVaultName")]
2339    #[serde(default)]
2340    pub backup_vault_name: String,
2341}
2342
2343#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2344pub struct GetBackupVaultAccessPolicyOutput {
2345    #[serde(rename = "BackupVaultArn")]
2346    #[serde(default)]
2347    #[serde(skip_serializing_if = "Option::is_none")]
2348    pub backup_vault_arn: Option<String>,
2349    #[serde(rename = "BackupVaultName")]
2350    #[serde(default)]
2351    #[serde(skip_serializing_if = "Option::is_none")]
2352    pub backup_vault_name: Option<String>,
2353    #[serde(rename = "Policy")]
2354    #[serde(default)]
2355    #[serde(skip_serializing_if = "Option::is_none")]
2356    pub policy: Option<String>,
2357}
2358
2359#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2360pub struct GetBackupVaultNotificationsInput {
2361    #[serde(rename = "BackupVaultName")]
2362    #[serde(default)]
2363    pub backup_vault_name: String,
2364}
2365
2366#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2367pub struct GetBackupVaultNotificationsOutput {
2368    #[serde(rename = "BackupVaultArn")]
2369    #[serde(default)]
2370    #[serde(skip_serializing_if = "Option::is_none")]
2371    pub backup_vault_arn: Option<String>,
2372    #[serde(rename = "BackupVaultEvents")]
2373    #[serde(default)]
2374    #[serde(skip_serializing_if = "Option::is_none")]
2375    pub backup_vault_events: Option<Vec<String>>,
2376    #[serde(rename = "BackupVaultName")]
2377    #[serde(default)]
2378    #[serde(skip_serializing_if = "Option::is_none")]
2379    pub backup_vault_name: Option<String>,
2380    #[serde(rename = "SNSTopicArn")]
2381    #[serde(default)]
2382    #[serde(skip_serializing_if = "Option::is_none")]
2383    pub s_n_s_topic_arn: Option<String>,
2384}
2385
2386#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2387pub struct GetLegalHoldInput {
2388    #[serde(rename = "LegalHoldId")]
2389    #[serde(default)]
2390    pub legal_hold_id: String,
2391}
2392
2393#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2394pub struct GetLegalHoldOutput {
2395    #[serde(rename = "CancelDescription")]
2396    #[serde(default)]
2397    #[serde(skip_serializing_if = "Option::is_none")]
2398    pub cancel_description: Option<String>,
2399    #[serde(rename = "CancellationDate")]
2400    #[serde(default)]
2401    #[serde(skip_serializing_if = "Option::is_none")]
2402    pub cancellation_date: Option<f64>,
2403    #[serde(rename = "CreationDate")]
2404    #[serde(default)]
2405    #[serde(skip_serializing_if = "Option::is_none")]
2406    pub creation_date: Option<f64>,
2407    #[serde(rename = "Description")]
2408    #[serde(default)]
2409    #[serde(skip_serializing_if = "Option::is_none")]
2410    pub description: Option<String>,
2411    #[serde(rename = "LegalHoldArn")]
2412    #[serde(default)]
2413    #[serde(skip_serializing_if = "Option::is_none")]
2414    pub legal_hold_arn: Option<String>,
2415    #[serde(rename = "LegalHoldId")]
2416    #[serde(default)]
2417    #[serde(skip_serializing_if = "Option::is_none")]
2418    pub legal_hold_id: Option<String>,
2419    #[serde(rename = "RecoveryPointSelection")]
2420    #[serde(default)]
2421    #[serde(skip_serializing_if = "Option::is_none")]
2422    pub recovery_point_selection: Option<RecoveryPointSelection>,
2423    #[serde(rename = "RetainRecordUntil")]
2424    #[serde(default)]
2425    #[serde(skip_serializing_if = "Option::is_none")]
2426    pub retain_record_until: Option<f64>,
2427    #[serde(rename = "Status")]
2428    #[serde(default)]
2429    #[serde(skip_serializing_if = "Option::is_none")]
2430    pub status: Option<String>,
2431    #[serde(rename = "Title")]
2432    #[serde(default)]
2433    #[serde(skip_serializing_if = "Option::is_none")]
2434    pub title: Option<String>,
2435}
2436
2437#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2438pub struct GetRecoveryPointIndexDetailsInput {
2439    #[serde(rename = "BackupVaultName")]
2440    #[serde(default)]
2441    pub backup_vault_name: String,
2442    #[serde(rename = "RecoveryPointArn")]
2443    #[serde(default)]
2444    pub recovery_point_arn: String,
2445}
2446
2447#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2448pub struct GetRecoveryPointIndexDetailsOutput {
2449    #[serde(rename = "BackupVaultArn")]
2450    #[serde(default)]
2451    #[serde(skip_serializing_if = "Option::is_none")]
2452    pub backup_vault_arn: Option<String>,
2453    #[serde(rename = "IndexCompletionDate")]
2454    #[serde(default)]
2455    #[serde(skip_serializing_if = "Option::is_none")]
2456    pub index_completion_date: Option<f64>,
2457    #[serde(rename = "IndexCreationDate")]
2458    #[serde(default)]
2459    #[serde(skip_serializing_if = "Option::is_none")]
2460    pub index_creation_date: Option<f64>,
2461    #[serde(rename = "IndexDeletionDate")]
2462    #[serde(default)]
2463    #[serde(skip_serializing_if = "Option::is_none")]
2464    pub index_deletion_date: Option<f64>,
2465    #[serde(rename = "IndexStatus")]
2466    #[serde(default)]
2467    #[serde(skip_serializing_if = "Option::is_none")]
2468    pub index_status: Option<String>,
2469    #[serde(rename = "IndexStatusMessage")]
2470    #[serde(default)]
2471    #[serde(skip_serializing_if = "Option::is_none")]
2472    pub index_status_message: Option<String>,
2473    #[serde(rename = "RecoveryPointArn")]
2474    #[serde(default)]
2475    #[serde(skip_serializing_if = "Option::is_none")]
2476    pub recovery_point_arn: Option<String>,
2477    #[serde(rename = "SourceResourceArn")]
2478    #[serde(default)]
2479    #[serde(skip_serializing_if = "Option::is_none")]
2480    pub source_resource_arn: Option<String>,
2481    #[serde(rename = "TotalItemsIndexed")]
2482    #[serde(default)]
2483    #[serde(skip_serializing_if = "Option::is_none")]
2484    pub total_items_indexed: Option<i64>,
2485}
2486
2487#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2488pub struct GetRecoveryPointRestoreMetadataInput {
2489    #[serde(rename = "BackupVaultAccountId")]
2490    #[serde(default)]
2491    #[serde(skip_serializing_if = "Option::is_none")]
2492    pub backup_vault_account_id: Option<String>,
2493    #[serde(rename = "BackupVaultName")]
2494    #[serde(default)]
2495    pub backup_vault_name: String,
2496    #[serde(rename = "RecoveryPointArn")]
2497    #[serde(default)]
2498    pub recovery_point_arn: String,
2499}
2500
2501#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2502pub struct GetRecoveryPointRestoreMetadataOutput {
2503    #[serde(rename = "BackupVaultArn")]
2504    #[serde(default)]
2505    #[serde(skip_serializing_if = "Option::is_none")]
2506    pub backup_vault_arn: Option<String>,
2507    #[serde(rename = "RecoveryPointArn")]
2508    #[serde(default)]
2509    #[serde(skip_serializing_if = "Option::is_none")]
2510    pub recovery_point_arn: Option<String>,
2511    #[serde(rename = "ResourceType")]
2512    #[serde(default)]
2513    #[serde(skip_serializing_if = "Option::is_none")]
2514    pub resource_type: Option<String>,
2515    #[serde(rename = "RestoreMetadata")]
2516    #[serde(default)]
2517    #[serde(skip_serializing_if = "Option::is_none")]
2518    pub restore_metadata: Option<std::collections::HashMap<String, String>>,
2519}
2520
2521#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2522pub struct GetRestoreJobMetadataInput {
2523    #[serde(rename = "RestoreJobId")]
2524    #[serde(default)]
2525    pub restore_job_id: String,
2526}
2527
2528#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2529pub struct GetRestoreJobMetadataOutput {
2530    #[serde(rename = "Metadata")]
2531    #[serde(default)]
2532    #[serde(skip_serializing_if = "Option::is_none")]
2533    pub metadata: Option<std::collections::HashMap<String, String>>,
2534    #[serde(rename = "RestoreJobId")]
2535    #[serde(default)]
2536    #[serde(skip_serializing_if = "Option::is_none")]
2537    pub restore_job_id: Option<String>,
2538}
2539
2540#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2541pub struct GetRestoreTestingInferredMetadataInput {
2542    #[serde(rename = "BackupVaultAccountId")]
2543    #[serde(default)]
2544    #[serde(skip_serializing_if = "Option::is_none")]
2545    pub backup_vault_account_id: Option<String>,
2546    #[serde(rename = "BackupVaultName")]
2547    #[serde(default)]
2548    pub backup_vault_name: String,
2549    #[serde(rename = "RecoveryPointArn")]
2550    #[serde(default)]
2551    pub recovery_point_arn: String,
2552}
2553
2554#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2555pub struct GetRestoreTestingInferredMetadataOutput {
2556    #[serde(rename = "InferredMetadata")]
2557    #[serde(default)]
2558    #[serde(skip_serializing_if = "Option::is_none")]
2559    pub inferred_metadata: Option<std::collections::HashMap<String, String>>,
2560}
2561
2562#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2563pub struct GetRestoreTestingPlanInput {
2564    #[serde(rename = "RestoreTestingPlanName")]
2565    #[serde(default)]
2566    pub restore_testing_plan_name: String,
2567}
2568
2569#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2570pub struct GetRestoreTestingPlanOutput {
2571    #[serde(rename = "RestoreTestingPlan")]
2572    #[serde(default)]
2573    #[serde(skip_serializing_if = "Option::is_none")]
2574    pub restore_testing_plan: Option<RestoreTestingPlanForGet>,
2575}
2576
2577#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2578pub struct RestoreTestingPlanForGet {
2579    #[serde(rename = "CreationTime")]
2580    #[serde(default)]
2581    #[serde(skip_serializing_if = "Option::is_none")]
2582    pub creation_time: Option<f64>,
2583    #[serde(rename = "CreatorRequestId")]
2584    #[serde(default)]
2585    #[serde(skip_serializing_if = "Option::is_none")]
2586    pub creator_request_id: Option<String>,
2587    #[serde(rename = "LastExecutionTime")]
2588    #[serde(default)]
2589    #[serde(skip_serializing_if = "Option::is_none")]
2590    pub last_execution_time: Option<f64>,
2591    #[serde(rename = "LastUpdateTime")]
2592    #[serde(default)]
2593    #[serde(skip_serializing_if = "Option::is_none")]
2594    pub last_update_time: Option<f64>,
2595    #[serde(rename = "RecoveryPointSelection")]
2596    #[serde(default)]
2597    #[serde(skip_serializing_if = "Option::is_none")]
2598    pub recovery_point_selection: Option<RestoreTestingRecoveryPointSelection>,
2599    #[serde(rename = "RestoreTestingPlanArn")]
2600    #[serde(default)]
2601    #[serde(skip_serializing_if = "Option::is_none")]
2602    pub restore_testing_plan_arn: Option<String>,
2603    #[serde(rename = "RestoreTestingPlanName")]
2604    #[serde(default)]
2605    #[serde(skip_serializing_if = "Option::is_none")]
2606    pub restore_testing_plan_name: Option<String>,
2607    #[serde(rename = "ScheduleExpression")]
2608    #[serde(default)]
2609    #[serde(skip_serializing_if = "Option::is_none")]
2610    pub schedule_expression: Option<String>,
2611    #[serde(rename = "ScheduleExpressionTimezone")]
2612    #[serde(default)]
2613    #[serde(skip_serializing_if = "Option::is_none")]
2614    pub schedule_expression_timezone: Option<String>,
2615    #[serde(rename = "StartWindowHours")]
2616    #[serde(default)]
2617    #[serde(skip_serializing_if = "Option::is_none")]
2618    pub start_window_hours: Option<i32>,
2619}
2620
2621#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2622pub struct GetRestoreTestingSelectionInput {
2623    #[serde(rename = "RestoreTestingPlanName")]
2624    #[serde(default)]
2625    pub restore_testing_plan_name: String,
2626    #[serde(rename = "RestoreTestingSelectionName")]
2627    #[serde(default)]
2628    pub restore_testing_selection_name: String,
2629}
2630
2631#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2632pub struct GetRestoreTestingSelectionOutput {
2633    #[serde(rename = "RestoreTestingSelection")]
2634    #[serde(default)]
2635    #[serde(skip_serializing_if = "Option::is_none")]
2636    pub restore_testing_selection: Option<RestoreTestingSelectionForGet>,
2637}
2638
2639#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2640pub struct RestoreTestingSelectionForGet {
2641    #[serde(rename = "CreationTime")]
2642    #[serde(default)]
2643    #[serde(skip_serializing_if = "Option::is_none")]
2644    pub creation_time: Option<f64>,
2645    #[serde(rename = "CreatorRequestId")]
2646    #[serde(default)]
2647    #[serde(skip_serializing_if = "Option::is_none")]
2648    pub creator_request_id: Option<String>,
2649    #[serde(rename = "IamRoleArn")]
2650    #[serde(default)]
2651    #[serde(skip_serializing_if = "Option::is_none")]
2652    pub iam_role_arn: Option<String>,
2653    #[serde(rename = "ProtectedResourceArns")]
2654    #[serde(default)]
2655    #[serde(skip_serializing_if = "Option::is_none")]
2656    pub protected_resource_arns: Option<Vec<String>>,
2657    #[serde(rename = "ProtectedResourceConditions")]
2658    #[serde(default)]
2659    #[serde(skip_serializing_if = "Option::is_none")]
2660    pub protected_resource_conditions: Option<ProtectedResourceConditions>,
2661    #[serde(rename = "ProtectedResourceType")]
2662    #[serde(default)]
2663    #[serde(skip_serializing_if = "Option::is_none")]
2664    pub protected_resource_type: Option<String>,
2665    #[serde(rename = "RestoreMetadataOverrides")]
2666    #[serde(default)]
2667    #[serde(skip_serializing_if = "Option::is_none")]
2668    pub restore_metadata_overrides: Option<std::collections::HashMap<String, String>>,
2669    #[serde(rename = "RestoreTestingPlanName")]
2670    #[serde(default)]
2671    #[serde(skip_serializing_if = "Option::is_none")]
2672    pub restore_testing_plan_name: Option<String>,
2673    #[serde(rename = "RestoreTestingSelectionName")]
2674    #[serde(default)]
2675    #[serde(skip_serializing_if = "Option::is_none")]
2676    pub restore_testing_selection_name: Option<String>,
2677    #[serde(rename = "ValidationWindowHours")]
2678    #[serde(default)]
2679    #[serde(skip_serializing_if = "Option::is_none")]
2680    pub validation_window_hours: Option<i32>,
2681}
2682
2683#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2684pub struct GetSupportedResourceTypesOutput {
2685    #[serde(rename = "ResourceTypes")]
2686    #[serde(default)]
2687    #[serde(skip_serializing_if = "Option::is_none")]
2688    pub resource_types: Option<Vec<String>>,
2689}
2690
2691#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2692pub struct GetTieringConfigurationInput {
2693    #[serde(rename = "TieringConfigurationName")]
2694    #[serde(default)]
2695    pub tiering_configuration_name: String,
2696}
2697
2698#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2699pub struct GetTieringConfigurationOutput {
2700    #[serde(rename = "TieringConfiguration")]
2701    #[serde(default)]
2702    #[serde(skip_serializing_if = "Option::is_none")]
2703    pub tiering_configuration: Option<TieringConfiguration>,
2704}
2705
2706#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2707pub struct TieringConfiguration {
2708    #[serde(rename = "BackupVaultName")]
2709    #[serde(default)]
2710    #[serde(skip_serializing_if = "Option::is_none")]
2711    pub backup_vault_name: Option<String>,
2712    #[serde(rename = "CreationTime")]
2713    #[serde(default)]
2714    #[serde(skip_serializing_if = "Option::is_none")]
2715    pub creation_time: Option<f64>,
2716    #[serde(rename = "CreatorRequestId")]
2717    #[serde(default)]
2718    #[serde(skip_serializing_if = "Option::is_none")]
2719    pub creator_request_id: Option<String>,
2720    #[serde(rename = "LastUpdatedTime")]
2721    #[serde(default)]
2722    #[serde(skip_serializing_if = "Option::is_none")]
2723    pub last_updated_time: Option<f64>,
2724    #[serde(rename = "ResourceSelection")]
2725    #[serde(default)]
2726    #[serde(skip_serializing_if = "Option::is_none")]
2727    pub resource_selection: Option<Vec<ResourceSelection>>,
2728    #[serde(rename = "TieringConfigurationArn")]
2729    #[serde(default)]
2730    #[serde(skip_serializing_if = "Option::is_none")]
2731    pub tiering_configuration_arn: Option<String>,
2732    #[serde(rename = "TieringConfigurationName")]
2733    #[serde(default)]
2734    #[serde(skip_serializing_if = "Option::is_none")]
2735    pub tiering_configuration_name: Option<String>,
2736}
2737
2738#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2739pub struct ListBackupJobSummariesInput {
2740    #[serde(rename = "AccountId")]
2741    #[serde(default)]
2742    #[serde(skip_serializing_if = "Option::is_none")]
2743    pub account_id: Option<String>,
2744    #[serde(rename = "AggregationPeriod")]
2745    #[serde(default)]
2746    #[serde(skip_serializing_if = "Option::is_none")]
2747    pub aggregation_period: Option<String>,
2748    #[serde(rename = "MaxResults")]
2749    #[serde(default)]
2750    #[serde(skip_serializing_if = "Option::is_none")]
2751    pub max_results: Option<i32>,
2752    #[serde(rename = "MessageCategory")]
2753    #[serde(default)]
2754    #[serde(skip_serializing_if = "Option::is_none")]
2755    pub message_category: Option<String>,
2756    #[serde(rename = "NextToken")]
2757    #[serde(default)]
2758    #[serde(skip_serializing_if = "Option::is_none")]
2759    pub next_token: Option<String>,
2760    #[serde(rename = "ResourceType")]
2761    #[serde(default)]
2762    #[serde(skip_serializing_if = "Option::is_none")]
2763    pub resource_type: Option<String>,
2764    #[serde(rename = "State")]
2765    #[serde(default)]
2766    #[serde(skip_serializing_if = "Option::is_none")]
2767    pub state: Option<String>,
2768}
2769
2770#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2771pub struct ListBackupJobSummariesOutput {
2772    #[serde(rename = "AggregationPeriod")]
2773    #[serde(default)]
2774    #[serde(skip_serializing_if = "Option::is_none")]
2775    pub aggregation_period: Option<String>,
2776    #[serde(rename = "BackupJobSummaries")]
2777    #[serde(default)]
2778    #[serde(skip_serializing_if = "Option::is_none")]
2779    pub backup_job_summaries: Option<Vec<BackupJobSummary>>,
2780    #[serde(rename = "NextToken")]
2781    #[serde(default)]
2782    #[serde(skip_serializing_if = "Option::is_none")]
2783    pub next_token: Option<String>,
2784}
2785
2786#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2787pub struct BackupJobSummary {
2788    #[serde(rename = "AccountId")]
2789    #[serde(default)]
2790    #[serde(skip_serializing_if = "Option::is_none")]
2791    pub account_id: Option<String>,
2792    #[serde(rename = "Count")]
2793    #[serde(default)]
2794    #[serde(skip_serializing_if = "Option::is_none")]
2795    pub count: Option<i32>,
2796    #[serde(rename = "EndTime")]
2797    #[serde(default)]
2798    #[serde(skip_serializing_if = "Option::is_none")]
2799    pub end_time: Option<f64>,
2800    #[serde(rename = "MessageCategory")]
2801    #[serde(default)]
2802    #[serde(skip_serializing_if = "Option::is_none")]
2803    pub message_category: Option<String>,
2804    #[serde(rename = "Region")]
2805    #[serde(default)]
2806    #[serde(skip_serializing_if = "Option::is_none")]
2807    pub region: Option<String>,
2808    #[serde(rename = "ResourceType")]
2809    #[serde(default)]
2810    #[serde(skip_serializing_if = "Option::is_none")]
2811    pub resource_type: Option<String>,
2812    #[serde(rename = "StartTime")]
2813    #[serde(default)]
2814    #[serde(skip_serializing_if = "Option::is_none")]
2815    pub start_time: Option<f64>,
2816    #[serde(rename = "State")]
2817    #[serde(default)]
2818    #[serde(skip_serializing_if = "Option::is_none")]
2819    pub state: Option<String>,
2820}
2821
2822#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2823pub struct ListBackupJobsInput {
2824    #[serde(rename = "ByAccountId")]
2825    #[serde(default)]
2826    #[serde(skip_serializing_if = "Option::is_none")]
2827    pub by_account_id: Option<String>,
2828    #[serde(rename = "ByBackupVaultName")]
2829    #[serde(default)]
2830    #[serde(skip_serializing_if = "Option::is_none")]
2831    pub by_backup_vault_name: Option<String>,
2832    #[serde(rename = "ByCompleteAfter")]
2833    #[serde(default)]
2834    #[serde(skip_serializing_if = "Option::is_none")]
2835    pub by_complete_after: Option<f64>,
2836    #[serde(rename = "ByCompleteBefore")]
2837    #[serde(default)]
2838    #[serde(skip_serializing_if = "Option::is_none")]
2839    pub by_complete_before: Option<f64>,
2840    #[serde(rename = "ByCreatedAfter")]
2841    #[serde(default)]
2842    #[serde(skip_serializing_if = "Option::is_none")]
2843    pub by_created_after: Option<f64>,
2844    #[serde(rename = "ByCreatedBefore")]
2845    #[serde(default)]
2846    #[serde(skip_serializing_if = "Option::is_none")]
2847    pub by_created_before: Option<f64>,
2848    #[serde(rename = "ByMessageCategory")]
2849    #[serde(default)]
2850    #[serde(skip_serializing_if = "Option::is_none")]
2851    pub by_message_category: Option<String>,
2852    #[serde(rename = "ByParentJobId")]
2853    #[serde(default)]
2854    #[serde(skip_serializing_if = "Option::is_none")]
2855    pub by_parent_job_id: Option<String>,
2856    #[serde(rename = "ByResourceArn")]
2857    #[serde(default)]
2858    #[serde(skip_serializing_if = "Option::is_none")]
2859    pub by_resource_arn: Option<String>,
2860    #[serde(rename = "ByResourceType")]
2861    #[serde(default)]
2862    #[serde(skip_serializing_if = "Option::is_none")]
2863    pub by_resource_type: Option<String>,
2864    #[serde(rename = "ByState")]
2865    #[serde(default)]
2866    #[serde(skip_serializing_if = "Option::is_none")]
2867    pub by_state: Option<String>,
2868    #[serde(rename = "MaxResults")]
2869    #[serde(default)]
2870    #[serde(skip_serializing_if = "Option::is_none")]
2871    pub max_results: Option<i32>,
2872    #[serde(rename = "NextToken")]
2873    #[serde(default)]
2874    #[serde(skip_serializing_if = "Option::is_none")]
2875    pub next_token: Option<String>,
2876}
2877
2878#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2879pub struct ListBackupJobsOutput {
2880    #[serde(rename = "BackupJobs")]
2881    #[serde(default)]
2882    #[serde(skip_serializing_if = "Option::is_none")]
2883    pub backup_jobs: Option<Vec<BackupJob>>,
2884    #[serde(rename = "NextToken")]
2885    #[serde(default)]
2886    #[serde(skip_serializing_if = "Option::is_none")]
2887    pub next_token: Option<String>,
2888}
2889
2890#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2891pub struct BackupJob {
2892    #[serde(rename = "AccountId")]
2893    #[serde(default)]
2894    #[serde(skip_serializing_if = "Option::is_none")]
2895    pub account_id: Option<String>,
2896    #[serde(rename = "BackupJobId")]
2897    #[serde(default)]
2898    #[serde(skip_serializing_if = "Option::is_none")]
2899    pub backup_job_id: Option<String>,
2900    #[serde(rename = "BackupOptions")]
2901    #[serde(default)]
2902    #[serde(skip_serializing_if = "Option::is_none")]
2903    pub backup_options: Option<std::collections::HashMap<String, String>>,
2904    #[serde(rename = "BackupSizeInBytes")]
2905    #[serde(default)]
2906    #[serde(skip_serializing_if = "Option::is_none")]
2907    pub backup_size_in_bytes: Option<i64>,
2908    #[serde(rename = "BackupType")]
2909    #[serde(default)]
2910    #[serde(skip_serializing_if = "Option::is_none")]
2911    pub backup_type: Option<String>,
2912    #[serde(rename = "BackupVaultArn")]
2913    #[serde(default)]
2914    #[serde(skip_serializing_if = "Option::is_none")]
2915    pub backup_vault_arn: Option<String>,
2916    #[serde(rename = "BackupVaultName")]
2917    #[serde(default)]
2918    #[serde(skip_serializing_if = "Option::is_none")]
2919    pub backup_vault_name: Option<String>,
2920    #[serde(rename = "BytesTransferred")]
2921    #[serde(default)]
2922    #[serde(skip_serializing_if = "Option::is_none")]
2923    pub bytes_transferred: Option<i64>,
2924    #[serde(rename = "CompletionDate")]
2925    #[serde(default)]
2926    #[serde(skip_serializing_if = "Option::is_none")]
2927    pub completion_date: Option<f64>,
2928    #[serde(rename = "CreatedBy")]
2929    #[serde(default)]
2930    #[serde(skip_serializing_if = "Option::is_none")]
2931    pub created_by: Option<RecoveryPointCreator>,
2932    #[serde(rename = "CreationDate")]
2933    #[serde(default)]
2934    #[serde(skip_serializing_if = "Option::is_none")]
2935    pub creation_date: Option<f64>,
2936    #[serde(rename = "EncryptionKeyArn")]
2937    #[serde(default)]
2938    #[serde(skip_serializing_if = "Option::is_none")]
2939    pub encryption_key_arn: Option<String>,
2940    #[serde(rename = "ExpectedCompletionDate")]
2941    #[serde(default)]
2942    #[serde(skip_serializing_if = "Option::is_none")]
2943    pub expected_completion_date: Option<f64>,
2944    #[serde(rename = "IamRoleArn")]
2945    #[serde(default)]
2946    #[serde(skip_serializing_if = "Option::is_none")]
2947    pub iam_role_arn: Option<String>,
2948    #[serde(rename = "InitiationDate")]
2949    #[serde(default)]
2950    #[serde(skip_serializing_if = "Option::is_none")]
2951    pub initiation_date: Option<f64>,
2952    #[serde(rename = "IsEncrypted")]
2953    #[serde(default)]
2954    #[serde(skip_serializing_if = "Option::is_none")]
2955    pub is_encrypted: Option<bool>,
2956    #[serde(rename = "IsParent")]
2957    #[serde(default)]
2958    #[serde(skip_serializing_if = "Option::is_none")]
2959    pub is_parent: Option<bool>,
2960    #[serde(rename = "MessageCategory")]
2961    #[serde(default)]
2962    #[serde(skip_serializing_if = "Option::is_none")]
2963    pub message_category: Option<String>,
2964    #[serde(rename = "ParentJobId")]
2965    #[serde(default)]
2966    #[serde(skip_serializing_if = "Option::is_none")]
2967    pub parent_job_id: Option<String>,
2968    #[serde(rename = "PercentDone")]
2969    #[serde(default)]
2970    #[serde(skip_serializing_if = "Option::is_none")]
2971    pub percent_done: Option<String>,
2972    #[serde(rename = "RecoveryPointArn")]
2973    #[serde(default)]
2974    #[serde(skip_serializing_if = "Option::is_none")]
2975    pub recovery_point_arn: Option<String>,
2976    #[serde(rename = "RecoveryPointLifecycle")]
2977    #[serde(default)]
2978    #[serde(skip_serializing_if = "Option::is_none")]
2979    pub recovery_point_lifecycle: Option<Lifecycle>,
2980    #[serde(rename = "ResourceArn")]
2981    #[serde(default)]
2982    #[serde(skip_serializing_if = "Option::is_none")]
2983    pub resource_arn: Option<String>,
2984    #[serde(rename = "ResourceName")]
2985    #[serde(default)]
2986    #[serde(skip_serializing_if = "Option::is_none")]
2987    pub resource_name: Option<String>,
2988    #[serde(rename = "ResourceType")]
2989    #[serde(default)]
2990    #[serde(skip_serializing_if = "Option::is_none")]
2991    pub resource_type: Option<String>,
2992    #[serde(rename = "StartBy")]
2993    #[serde(default)]
2994    #[serde(skip_serializing_if = "Option::is_none")]
2995    pub start_by: Option<f64>,
2996    #[serde(rename = "State")]
2997    #[serde(default)]
2998    #[serde(skip_serializing_if = "Option::is_none")]
2999    pub state: Option<String>,
3000    #[serde(rename = "StatusMessage")]
3001    #[serde(default)]
3002    #[serde(skip_serializing_if = "Option::is_none")]
3003    pub status_message: Option<String>,
3004    #[serde(rename = "VaultLockState")]
3005    #[serde(default)]
3006    #[serde(skip_serializing_if = "Option::is_none")]
3007    pub vault_lock_state: Option<String>,
3008    #[serde(rename = "VaultType")]
3009    #[serde(default)]
3010    #[serde(skip_serializing_if = "Option::is_none")]
3011    pub vault_type: Option<String>,
3012}
3013
3014#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3015pub struct ListBackupPlanTemplatesInput {
3016    #[serde(rename = "MaxResults")]
3017    #[serde(default)]
3018    #[serde(skip_serializing_if = "Option::is_none")]
3019    pub max_results: Option<i32>,
3020    #[serde(rename = "NextToken")]
3021    #[serde(default)]
3022    #[serde(skip_serializing_if = "Option::is_none")]
3023    pub next_token: Option<String>,
3024}
3025
3026#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3027pub struct ListBackupPlanTemplatesOutput {
3028    #[serde(rename = "BackupPlanTemplatesList")]
3029    #[serde(default)]
3030    #[serde(skip_serializing_if = "Option::is_none")]
3031    pub backup_plan_templates_list: Option<Vec<BackupPlanTemplatesListMember>>,
3032    #[serde(rename = "NextToken")]
3033    #[serde(default)]
3034    #[serde(skip_serializing_if = "Option::is_none")]
3035    pub next_token: Option<String>,
3036}
3037
3038#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3039pub struct BackupPlanTemplatesListMember {
3040    #[serde(rename = "BackupPlanTemplateId")]
3041    #[serde(default)]
3042    #[serde(skip_serializing_if = "Option::is_none")]
3043    pub backup_plan_template_id: Option<String>,
3044    #[serde(rename = "BackupPlanTemplateName")]
3045    #[serde(default)]
3046    #[serde(skip_serializing_if = "Option::is_none")]
3047    pub backup_plan_template_name: Option<String>,
3048}
3049
3050#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3051pub struct ListBackupPlanVersionsInput {
3052    #[serde(rename = "BackupPlanId")]
3053    #[serde(default)]
3054    pub backup_plan_id: String,
3055    #[serde(rename = "MaxResults")]
3056    #[serde(default)]
3057    #[serde(skip_serializing_if = "Option::is_none")]
3058    pub max_results: Option<i32>,
3059    #[serde(rename = "NextToken")]
3060    #[serde(default)]
3061    #[serde(skip_serializing_if = "Option::is_none")]
3062    pub next_token: Option<String>,
3063}
3064
3065#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3066pub struct ListBackupPlanVersionsOutput {
3067    #[serde(rename = "BackupPlanVersionsList")]
3068    #[serde(default)]
3069    #[serde(skip_serializing_if = "Option::is_none")]
3070    pub backup_plan_versions_list: Option<Vec<BackupPlansListMember>>,
3071    #[serde(rename = "NextToken")]
3072    #[serde(default)]
3073    #[serde(skip_serializing_if = "Option::is_none")]
3074    pub next_token: Option<String>,
3075}
3076
3077#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3078pub struct BackupPlansListMember {
3079    #[serde(rename = "AdvancedBackupSettings")]
3080    #[serde(default)]
3081    #[serde(skip_serializing_if = "Option::is_none")]
3082    pub advanced_backup_settings: Option<Vec<AdvancedBackupSetting>>,
3083    #[serde(rename = "BackupPlanArn")]
3084    #[serde(default)]
3085    #[serde(skip_serializing_if = "Option::is_none")]
3086    pub backup_plan_arn: Option<String>,
3087    #[serde(rename = "BackupPlanId")]
3088    #[serde(default)]
3089    #[serde(skip_serializing_if = "Option::is_none")]
3090    pub backup_plan_id: Option<String>,
3091    #[serde(rename = "BackupPlanName")]
3092    #[serde(default)]
3093    #[serde(skip_serializing_if = "Option::is_none")]
3094    pub backup_plan_name: Option<String>,
3095    #[serde(rename = "CreationDate")]
3096    #[serde(default)]
3097    #[serde(skip_serializing_if = "Option::is_none")]
3098    pub creation_date: Option<f64>,
3099    #[serde(rename = "CreatorRequestId")]
3100    #[serde(default)]
3101    #[serde(skip_serializing_if = "Option::is_none")]
3102    pub creator_request_id: Option<String>,
3103    #[serde(rename = "DeletionDate")]
3104    #[serde(default)]
3105    #[serde(skip_serializing_if = "Option::is_none")]
3106    pub deletion_date: Option<f64>,
3107    #[serde(rename = "LastExecutionDate")]
3108    #[serde(default)]
3109    #[serde(skip_serializing_if = "Option::is_none")]
3110    pub last_execution_date: Option<f64>,
3111    #[serde(rename = "VersionId")]
3112    #[serde(default)]
3113    #[serde(skip_serializing_if = "Option::is_none")]
3114    pub version_id: Option<String>,
3115}
3116
3117#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3118pub struct ListBackupPlansInput {
3119    #[serde(rename = "IncludeDeleted")]
3120    #[serde(default)]
3121    #[serde(skip_serializing_if = "Option::is_none")]
3122    pub include_deleted: Option<bool>,
3123    #[serde(rename = "MaxResults")]
3124    #[serde(default)]
3125    #[serde(skip_serializing_if = "Option::is_none")]
3126    pub max_results: Option<i32>,
3127    #[serde(rename = "NextToken")]
3128    #[serde(default)]
3129    #[serde(skip_serializing_if = "Option::is_none")]
3130    pub next_token: Option<String>,
3131}
3132
3133#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3134pub struct ListBackupPlansOutput {
3135    #[serde(rename = "BackupPlansList")]
3136    #[serde(default)]
3137    #[serde(skip_serializing_if = "Option::is_none")]
3138    pub backup_plans_list: Option<Vec<BackupPlansListMember>>,
3139    #[serde(rename = "NextToken")]
3140    #[serde(default)]
3141    #[serde(skip_serializing_if = "Option::is_none")]
3142    pub next_token: Option<String>,
3143}
3144
3145#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3146pub struct ListBackupSelectionsInput {
3147    #[serde(rename = "BackupPlanId")]
3148    #[serde(default)]
3149    pub backup_plan_id: String,
3150    #[serde(rename = "MaxResults")]
3151    #[serde(default)]
3152    #[serde(skip_serializing_if = "Option::is_none")]
3153    pub max_results: Option<i32>,
3154    #[serde(rename = "NextToken")]
3155    #[serde(default)]
3156    #[serde(skip_serializing_if = "Option::is_none")]
3157    pub next_token: Option<String>,
3158}
3159
3160#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3161pub struct ListBackupSelectionsOutput {
3162    #[serde(rename = "BackupSelectionsList")]
3163    #[serde(default)]
3164    #[serde(skip_serializing_if = "Option::is_none")]
3165    pub backup_selections_list: Option<Vec<BackupSelectionsListMember>>,
3166    #[serde(rename = "NextToken")]
3167    #[serde(default)]
3168    #[serde(skip_serializing_if = "Option::is_none")]
3169    pub next_token: Option<String>,
3170}
3171
3172#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3173pub struct BackupSelectionsListMember {
3174    #[serde(rename = "BackupPlanId")]
3175    #[serde(default)]
3176    #[serde(skip_serializing_if = "Option::is_none")]
3177    pub backup_plan_id: Option<String>,
3178    #[serde(rename = "CreationDate")]
3179    #[serde(default)]
3180    #[serde(skip_serializing_if = "Option::is_none")]
3181    pub creation_date: Option<f64>,
3182    #[serde(rename = "CreatorRequestId")]
3183    #[serde(default)]
3184    #[serde(skip_serializing_if = "Option::is_none")]
3185    pub creator_request_id: Option<String>,
3186    #[serde(rename = "IamRoleArn")]
3187    #[serde(default)]
3188    #[serde(skip_serializing_if = "Option::is_none")]
3189    pub iam_role_arn: Option<String>,
3190    #[serde(rename = "SelectionId")]
3191    #[serde(default)]
3192    #[serde(skip_serializing_if = "Option::is_none")]
3193    pub selection_id: Option<String>,
3194    #[serde(rename = "SelectionName")]
3195    #[serde(default)]
3196    #[serde(skip_serializing_if = "Option::is_none")]
3197    pub selection_name: Option<String>,
3198}
3199
3200#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3201pub struct ListBackupVaultsInput {
3202    #[serde(rename = "ByShared")]
3203    #[serde(default)]
3204    #[serde(skip_serializing_if = "Option::is_none")]
3205    pub by_shared: Option<bool>,
3206    #[serde(rename = "ByVaultType")]
3207    #[serde(default)]
3208    #[serde(skip_serializing_if = "Option::is_none")]
3209    pub by_vault_type: Option<String>,
3210    #[serde(rename = "MaxResults")]
3211    #[serde(default)]
3212    #[serde(skip_serializing_if = "Option::is_none")]
3213    pub max_results: Option<i32>,
3214    #[serde(rename = "NextToken")]
3215    #[serde(default)]
3216    #[serde(skip_serializing_if = "Option::is_none")]
3217    pub next_token: Option<String>,
3218}
3219
3220#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3221pub struct ListBackupVaultsOutput {
3222    #[serde(rename = "BackupVaultList")]
3223    #[serde(default)]
3224    #[serde(skip_serializing_if = "Option::is_none")]
3225    pub backup_vault_list: Option<Vec<BackupVaultListMember>>,
3226    #[serde(rename = "NextToken")]
3227    #[serde(default)]
3228    #[serde(skip_serializing_if = "Option::is_none")]
3229    pub next_token: Option<String>,
3230}
3231
3232#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3233pub struct BackupVaultListMember {
3234    #[serde(rename = "BackupVaultArn")]
3235    #[serde(default)]
3236    #[serde(skip_serializing_if = "Option::is_none")]
3237    pub backup_vault_arn: Option<String>,
3238    #[serde(rename = "BackupVaultName")]
3239    #[serde(default)]
3240    #[serde(skip_serializing_if = "Option::is_none")]
3241    pub backup_vault_name: Option<String>,
3242    #[serde(rename = "CreationDate")]
3243    #[serde(default)]
3244    #[serde(skip_serializing_if = "Option::is_none")]
3245    pub creation_date: Option<f64>,
3246    #[serde(rename = "CreatorRequestId")]
3247    #[serde(default)]
3248    #[serde(skip_serializing_if = "Option::is_none")]
3249    pub creator_request_id: Option<String>,
3250    #[serde(rename = "EncryptionKeyArn")]
3251    #[serde(default)]
3252    #[serde(skip_serializing_if = "Option::is_none")]
3253    pub encryption_key_arn: Option<String>,
3254    #[serde(rename = "EncryptionKeyType")]
3255    #[serde(default)]
3256    #[serde(skip_serializing_if = "Option::is_none")]
3257    pub encryption_key_type: Option<String>,
3258    #[serde(rename = "LockDate")]
3259    #[serde(default)]
3260    #[serde(skip_serializing_if = "Option::is_none")]
3261    pub lock_date: Option<f64>,
3262    #[serde(rename = "Locked")]
3263    #[serde(default)]
3264    #[serde(skip_serializing_if = "Option::is_none")]
3265    pub locked: Option<bool>,
3266    #[serde(rename = "MaxRetentionDays")]
3267    #[serde(default)]
3268    #[serde(skip_serializing_if = "Option::is_none")]
3269    pub max_retention_days: Option<i64>,
3270    #[serde(rename = "MinRetentionDays")]
3271    #[serde(default)]
3272    #[serde(skip_serializing_if = "Option::is_none")]
3273    pub min_retention_days: Option<i64>,
3274    #[serde(rename = "NumberOfRecoveryPoints")]
3275    #[serde(default)]
3276    #[serde(skip_serializing_if = "Option::is_none")]
3277    pub number_of_recovery_points: Option<i64>,
3278    #[serde(rename = "VaultState")]
3279    #[serde(default)]
3280    #[serde(skip_serializing_if = "Option::is_none")]
3281    pub vault_state: Option<String>,
3282    #[serde(rename = "VaultType")]
3283    #[serde(default)]
3284    #[serde(skip_serializing_if = "Option::is_none")]
3285    pub vault_type: Option<String>,
3286}
3287
3288#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3289pub struct ListCopyJobSummariesInput {
3290    #[serde(rename = "AccountId")]
3291    #[serde(default)]
3292    #[serde(skip_serializing_if = "Option::is_none")]
3293    pub account_id: Option<String>,
3294    #[serde(rename = "AggregationPeriod")]
3295    #[serde(default)]
3296    #[serde(skip_serializing_if = "Option::is_none")]
3297    pub aggregation_period: Option<String>,
3298    #[serde(rename = "MaxResults")]
3299    #[serde(default)]
3300    #[serde(skip_serializing_if = "Option::is_none")]
3301    pub max_results: Option<i32>,
3302    #[serde(rename = "MessageCategory")]
3303    #[serde(default)]
3304    #[serde(skip_serializing_if = "Option::is_none")]
3305    pub message_category: Option<String>,
3306    #[serde(rename = "NextToken")]
3307    #[serde(default)]
3308    #[serde(skip_serializing_if = "Option::is_none")]
3309    pub next_token: Option<String>,
3310    #[serde(rename = "ResourceType")]
3311    #[serde(default)]
3312    #[serde(skip_serializing_if = "Option::is_none")]
3313    pub resource_type: Option<String>,
3314    #[serde(rename = "State")]
3315    #[serde(default)]
3316    #[serde(skip_serializing_if = "Option::is_none")]
3317    pub state: Option<String>,
3318}
3319
3320#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3321pub struct ListCopyJobSummariesOutput {
3322    #[serde(rename = "AggregationPeriod")]
3323    #[serde(default)]
3324    #[serde(skip_serializing_if = "Option::is_none")]
3325    pub aggregation_period: Option<String>,
3326    #[serde(rename = "CopyJobSummaries")]
3327    #[serde(default)]
3328    #[serde(skip_serializing_if = "Option::is_none")]
3329    pub copy_job_summaries: Option<Vec<CopyJobSummary>>,
3330    #[serde(rename = "NextToken")]
3331    #[serde(default)]
3332    #[serde(skip_serializing_if = "Option::is_none")]
3333    pub next_token: Option<String>,
3334}
3335
3336#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3337pub struct CopyJobSummary {
3338    #[serde(rename = "AccountId")]
3339    #[serde(default)]
3340    #[serde(skip_serializing_if = "Option::is_none")]
3341    pub account_id: Option<String>,
3342    #[serde(rename = "Count")]
3343    #[serde(default)]
3344    #[serde(skip_serializing_if = "Option::is_none")]
3345    pub count: Option<i32>,
3346    #[serde(rename = "EndTime")]
3347    #[serde(default)]
3348    #[serde(skip_serializing_if = "Option::is_none")]
3349    pub end_time: Option<f64>,
3350    #[serde(rename = "MessageCategory")]
3351    #[serde(default)]
3352    #[serde(skip_serializing_if = "Option::is_none")]
3353    pub message_category: Option<String>,
3354    #[serde(rename = "Region")]
3355    #[serde(default)]
3356    #[serde(skip_serializing_if = "Option::is_none")]
3357    pub region: Option<String>,
3358    #[serde(rename = "ResourceType")]
3359    #[serde(default)]
3360    #[serde(skip_serializing_if = "Option::is_none")]
3361    pub resource_type: Option<String>,
3362    #[serde(rename = "StartTime")]
3363    #[serde(default)]
3364    #[serde(skip_serializing_if = "Option::is_none")]
3365    pub start_time: Option<f64>,
3366    #[serde(rename = "State")]
3367    #[serde(default)]
3368    #[serde(skip_serializing_if = "Option::is_none")]
3369    pub state: Option<String>,
3370}
3371
3372#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3373pub struct ListCopyJobsInput {
3374    #[serde(rename = "ByAccountId")]
3375    #[serde(default)]
3376    #[serde(skip_serializing_if = "Option::is_none")]
3377    pub by_account_id: Option<String>,
3378    #[serde(rename = "ByCompleteAfter")]
3379    #[serde(default)]
3380    #[serde(skip_serializing_if = "Option::is_none")]
3381    pub by_complete_after: Option<f64>,
3382    #[serde(rename = "ByCompleteBefore")]
3383    #[serde(default)]
3384    #[serde(skip_serializing_if = "Option::is_none")]
3385    pub by_complete_before: Option<f64>,
3386    #[serde(rename = "ByCreatedAfter")]
3387    #[serde(default)]
3388    #[serde(skip_serializing_if = "Option::is_none")]
3389    pub by_created_after: Option<f64>,
3390    #[serde(rename = "ByCreatedBefore")]
3391    #[serde(default)]
3392    #[serde(skip_serializing_if = "Option::is_none")]
3393    pub by_created_before: Option<f64>,
3394    #[serde(rename = "ByDestinationVaultArn")]
3395    #[serde(default)]
3396    #[serde(skip_serializing_if = "Option::is_none")]
3397    pub by_destination_vault_arn: Option<String>,
3398    #[serde(rename = "ByMessageCategory")]
3399    #[serde(default)]
3400    #[serde(skip_serializing_if = "Option::is_none")]
3401    pub by_message_category: Option<String>,
3402    #[serde(rename = "ByParentJobId")]
3403    #[serde(default)]
3404    #[serde(skip_serializing_if = "Option::is_none")]
3405    pub by_parent_job_id: Option<String>,
3406    #[serde(rename = "ByResourceArn")]
3407    #[serde(default)]
3408    #[serde(skip_serializing_if = "Option::is_none")]
3409    pub by_resource_arn: Option<String>,
3410    #[serde(rename = "ByResourceType")]
3411    #[serde(default)]
3412    #[serde(skip_serializing_if = "Option::is_none")]
3413    pub by_resource_type: Option<String>,
3414    #[serde(rename = "BySourceRecoveryPointArn")]
3415    #[serde(default)]
3416    #[serde(skip_serializing_if = "Option::is_none")]
3417    pub by_source_recovery_point_arn: Option<String>,
3418    #[serde(rename = "ByState")]
3419    #[serde(default)]
3420    #[serde(skip_serializing_if = "Option::is_none")]
3421    pub by_state: Option<String>,
3422    #[serde(rename = "MaxResults")]
3423    #[serde(default)]
3424    #[serde(skip_serializing_if = "Option::is_none")]
3425    pub max_results: Option<i32>,
3426    #[serde(rename = "NextToken")]
3427    #[serde(default)]
3428    #[serde(skip_serializing_if = "Option::is_none")]
3429    pub next_token: Option<String>,
3430}
3431
3432#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3433pub struct ListCopyJobsOutput {
3434    #[serde(rename = "CopyJobs")]
3435    #[serde(default)]
3436    #[serde(skip_serializing_if = "Option::is_none")]
3437    pub copy_jobs: Option<Vec<CopyJob>>,
3438    #[serde(rename = "NextToken")]
3439    #[serde(default)]
3440    #[serde(skip_serializing_if = "Option::is_none")]
3441    pub next_token: Option<String>,
3442}
3443
3444#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3445pub struct ListFrameworksInput {
3446    #[serde(rename = "MaxResults")]
3447    #[serde(default)]
3448    #[serde(skip_serializing_if = "Option::is_none")]
3449    pub max_results: Option<i32>,
3450    #[serde(rename = "NextToken")]
3451    #[serde(default)]
3452    #[serde(skip_serializing_if = "Option::is_none")]
3453    pub next_token: Option<String>,
3454}
3455
3456#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3457pub struct ListFrameworksOutput {
3458    #[serde(rename = "Frameworks")]
3459    #[serde(default)]
3460    #[serde(skip_serializing_if = "Option::is_none")]
3461    pub frameworks: Option<Vec<Framework>>,
3462    #[serde(rename = "NextToken")]
3463    #[serde(default)]
3464    #[serde(skip_serializing_if = "Option::is_none")]
3465    pub next_token: Option<String>,
3466}
3467
3468#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3469pub struct Framework {
3470    #[serde(rename = "CreationTime")]
3471    #[serde(default)]
3472    #[serde(skip_serializing_if = "Option::is_none")]
3473    pub creation_time: Option<f64>,
3474    #[serde(rename = "DeploymentStatus")]
3475    #[serde(default)]
3476    #[serde(skip_serializing_if = "Option::is_none")]
3477    pub deployment_status: Option<String>,
3478    #[serde(rename = "FrameworkArn")]
3479    #[serde(default)]
3480    #[serde(skip_serializing_if = "Option::is_none")]
3481    pub framework_arn: Option<String>,
3482    #[serde(rename = "FrameworkDescription")]
3483    #[serde(default)]
3484    #[serde(skip_serializing_if = "Option::is_none")]
3485    pub framework_description: Option<String>,
3486    #[serde(rename = "FrameworkName")]
3487    #[serde(default)]
3488    #[serde(skip_serializing_if = "Option::is_none")]
3489    pub framework_name: Option<String>,
3490    #[serde(rename = "NumberOfControls")]
3491    #[serde(default)]
3492    #[serde(skip_serializing_if = "Option::is_none")]
3493    pub number_of_controls: Option<i32>,
3494}
3495
3496#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3497pub struct ListIndexedRecoveryPointsInput {
3498    #[serde(rename = "CreatedAfter")]
3499    #[serde(default)]
3500    #[serde(skip_serializing_if = "Option::is_none")]
3501    pub created_after: Option<f64>,
3502    #[serde(rename = "CreatedBefore")]
3503    #[serde(default)]
3504    #[serde(skip_serializing_if = "Option::is_none")]
3505    pub created_before: Option<f64>,
3506    #[serde(rename = "IndexStatus")]
3507    #[serde(default)]
3508    #[serde(skip_serializing_if = "Option::is_none")]
3509    pub index_status: Option<String>,
3510    #[serde(rename = "MaxResults")]
3511    #[serde(default)]
3512    #[serde(skip_serializing_if = "Option::is_none")]
3513    pub max_results: Option<i32>,
3514    #[serde(rename = "NextToken")]
3515    #[serde(default)]
3516    #[serde(skip_serializing_if = "Option::is_none")]
3517    pub next_token: Option<String>,
3518    #[serde(rename = "ResourceType")]
3519    #[serde(default)]
3520    #[serde(skip_serializing_if = "Option::is_none")]
3521    pub resource_type: Option<String>,
3522    #[serde(rename = "SourceResourceArn")]
3523    #[serde(default)]
3524    #[serde(skip_serializing_if = "Option::is_none")]
3525    pub source_resource_arn: Option<String>,
3526}
3527
3528#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3529pub struct ListIndexedRecoveryPointsOutput {
3530    #[serde(rename = "IndexedRecoveryPoints")]
3531    #[serde(default)]
3532    #[serde(skip_serializing_if = "Option::is_none")]
3533    pub indexed_recovery_points: Option<Vec<IndexedRecoveryPoint>>,
3534    #[serde(rename = "NextToken")]
3535    #[serde(default)]
3536    #[serde(skip_serializing_if = "Option::is_none")]
3537    pub next_token: Option<String>,
3538}
3539
3540#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3541pub struct IndexedRecoveryPoint {
3542    #[serde(rename = "BackupCreationDate")]
3543    #[serde(default)]
3544    #[serde(skip_serializing_if = "Option::is_none")]
3545    pub backup_creation_date: Option<f64>,
3546    #[serde(rename = "BackupVaultArn")]
3547    #[serde(default)]
3548    #[serde(skip_serializing_if = "Option::is_none")]
3549    pub backup_vault_arn: Option<String>,
3550    #[serde(rename = "IamRoleArn")]
3551    #[serde(default)]
3552    #[serde(skip_serializing_if = "Option::is_none")]
3553    pub iam_role_arn: Option<String>,
3554    #[serde(rename = "IndexCreationDate")]
3555    #[serde(default)]
3556    #[serde(skip_serializing_if = "Option::is_none")]
3557    pub index_creation_date: Option<f64>,
3558    #[serde(rename = "IndexStatus")]
3559    #[serde(default)]
3560    #[serde(skip_serializing_if = "Option::is_none")]
3561    pub index_status: Option<String>,
3562    #[serde(rename = "IndexStatusMessage")]
3563    #[serde(default)]
3564    #[serde(skip_serializing_if = "Option::is_none")]
3565    pub index_status_message: Option<String>,
3566    #[serde(rename = "RecoveryPointArn")]
3567    #[serde(default)]
3568    #[serde(skip_serializing_if = "Option::is_none")]
3569    pub recovery_point_arn: Option<String>,
3570    #[serde(rename = "ResourceType")]
3571    #[serde(default)]
3572    #[serde(skip_serializing_if = "Option::is_none")]
3573    pub resource_type: Option<String>,
3574    #[serde(rename = "SourceResourceArn")]
3575    #[serde(default)]
3576    #[serde(skip_serializing_if = "Option::is_none")]
3577    pub source_resource_arn: Option<String>,
3578}
3579
3580#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3581pub struct ListLegalHoldsInput {
3582    #[serde(rename = "MaxResults")]
3583    #[serde(default)]
3584    #[serde(skip_serializing_if = "Option::is_none")]
3585    pub max_results: Option<i32>,
3586    #[serde(rename = "NextToken")]
3587    #[serde(default)]
3588    #[serde(skip_serializing_if = "Option::is_none")]
3589    pub next_token: Option<String>,
3590}
3591
3592#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3593pub struct ListLegalHoldsOutput {
3594    #[serde(rename = "LegalHolds")]
3595    #[serde(default)]
3596    #[serde(skip_serializing_if = "Option::is_none")]
3597    pub legal_holds: Option<Vec<LegalHold>>,
3598    #[serde(rename = "NextToken")]
3599    #[serde(default)]
3600    #[serde(skip_serializing_if = "Option::is_none")]
3601    pub next_token: Option<String>,
3602}
3603
3604#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3605pub struct LegalHold {
3606    #[serde(rename = "CancellationDate")]
3607    #[serde(default)]
3608    #[serde(skip_serializing_if = "Option::is_none")]
3609    pub cancellation_date: Option<f64>,
3610    #[serde(rename = "CreationDate")]
3611    #[serde(default)]
3612    #[serde(skip_serializing_if = "Option::is_none")]
3613    pub creation_date: Option<f64>,
3614    #[serde(rename = "Description")]
3615    #[serde(default)]
3616    #[serde(skip_serializing_if = "Option::is_none")]
3617    pub description: Option<String>,
3618    #[serde(rename = "LegalHoldArn")]
3619    #[serde(default)]
3620    #[serde(skip_serializing_if = "Option::is_none")]
3621    pub legal_hold_arn: Option<String>,
3622    #[serde(rename = "LegalHoldId")]
3623    #[serde(default)]
3624    #[serde(skip_serializing_if = "Option::is_none")]
3625    pub legal_hold_id: Option<String>,
3626    #[serde(rename = "Status")]
3627    #[serde(default)]
3628    #[serde(skip_serializing_if = "Option::is_none")]
3629    pub status: Option<String>,
3630    #[serde(rename = "Title")]
3631    #[serde(default)]
3632    #[serde(skip_serializing_if = "Option::is_none")]
3633    pub title: Option<String>,
3634}
3635
3636#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3637pub struct ListProtectedResourcesByBackupVaultInput {
3638    #[serde(rename = "BackupVaultAccountId")]
3639    #[serde(default)]
3640    #[serde(skip_serializing_if = "Option::is_none")]
3641    pub backup_vault_account_id: Option<String>,
3642    #[serde(rename = "BackupVaultName")]
3643    #[serde(default)]
3644    pub backup_vault_name: String,
3645    #[serde(rename = "MaxResults")]
3646    #[serde(default)]
3647    #[serde(skip_serializing_if = "Option::is_none")]
3648    pub max_results: Option<i32>,
3649    #[serde(rename = "NextToken")]
3650    #[serde(default)]
3651    #[serde(skip_serializing_if = "Option::is_none")]
3652    pub next_token: Option<String>,
3653}
3654
3655#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3656pub struct ListProtectedResourcesByBackupVaultOutput {
3657    #[serde(rename = "NextToken")]
3658    #[serde(default)]
3659    #[serde(skip_serializing_if = "Option::is_none")]
3660    pub next_token: Option<String>,
3661    #[serde(rename = "Results")]
3662    #[serde(default)]
3663    #[serde(skip_serializing_if = "Option::is_none")]
3664    pub results: Option<Vec<ProtectedResource>>,
3665}
3666
3667#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3668pub struct ProtectedResource {
3669    #[serde(rename = "LastBackupTime")]
3670    #[serde(default)]
3671    #[serde(skip_serializing_if = "Option::is_none")]
3672    pub last_backup_time: Option<f64>,
3673    #[serde(rename = "LastBackupVaultArn")]
3674    #[serde(default)]
3675    #[serde(skip_serializing_if = "Option::is_none")]
3676    pub last_backup_vault_arn: Option<String>,
3677    #[serde(rename = "LastRecoveryPointArn")]
3678    #[serde(default)]
3679    #[serde(skip_serializing_if = "Option::is_none")]
3680    pub last_recovery_point_arn: Option<String>,
3681    #[serde(rename = "ResourceArn")]
3682    #[serde(default)]
3683    #[serde(skip_serializing_if = "Option::is_none")]
3684    pub resource_arn: Option<String>,
3685    #[serde(rename = "ResourceName")]
3686    #[serde(default)]
3687    #[serde(skip_serializing_if = "Option::is_none")]
3688    pub resource_name: Option<String>,
3689    #[serde(rename = "ResourceType")]
3690    #[serde(default)]
3691    #[serde(skip_serializing_if = "Option::is_none")]
3692    pub resource_type: Option<String>,
3693}
3694
3695#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3696pub struct ListProtectedResourcesInput {
3697    #[serde(rename = "MaxResults")]
3698    #[serde(default)]
3699    #[serde(skip_serializing_if = "Option::is_none")]
3700    pub max_results: Option<i32>,
3701    #[serde(rename = "NextToken")]
3702    #[serde(default)]
3703    #[serde(skip_serializing_if = "Option::is_none")]
3704    pub next_token: Option<String>,
3705}
3706
3707#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3708pub struct ListProtectedResourcesOutput {
3709    #[serde(rename = "NextToken")]
3710    #[serde(default)]
3711    #[serde(skip_serializing_if = "Option::is_none")]
3712    pub next_token: Option<String>,
3713    #[serde(rename = "Results")]
3714    #[serde(default)]
3715    #[serde(skip_serializing_if = "Option::is_none")]
3716    pub results: Option<Vec<ProtectedResource>>,
3717}
3718
3719#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3720pub struct ListRecoveryPointsByBackupVaultInput {
3721    #[serde(rename = "BackupVaultAccountId")]
3722    #[serde(default)]
3723    #[serde(skip_serializing_if = "Option::is_none")]
3724    pub backup_vault_account_id: Option<String>,
3725    #[serde(rename = "BackupVaultName")]
3726    #[serde(default)]
3727    pub backup_vault_name: String,
3728    #[serde(rename = "ByBackupPlanId")]
3729    #[serde(default)]
3730    #[serde(skip_serializing_if = "Option::is_none")]
3731    pub by_backup_plan_id: Option<String>,
3732    #[serde(rename = "ByCreatedAfter")]
3733    #[serde(default)]
3734    #[serde(skip_serializing_if = "Option::is_none")]
3735    pub by_created_after: Option<f64>,
3736    #[serde(rename = "ByCreatedBefore")]
3737    #[serde(default)]
3738    #[serde(skip_serializing_if = "Option::is_none")]
3739    pub by_created_before: Option<f64>,
3740    #[serde(rename = "ByParentRecoveryPointArn")]
3741    #[serde(default)]
3742    #[serde(skip_serializing_if = "Option::is_none")]
3743    pub by_parent_recovery_point_arn: Option<String>,
3744    #[serde(rename = "ByResourceArn")]
3745    #[serde(default)]
3746    #[serde(skip_serializing_if = "Option::is_none")]
3747    pub by_resource_arn: Option<String>,
3748    #[serde(rename = "ByResourceType")]
3749    #[serde(default)]
3750    #[serde(skip_serializing_if = "Option::is_none")]
3751    pub by_resource_type: Option<String>,
3752    #[serde(rename = "MaxResults")]
3753    #[serde(default)]
3754    #[serde(skip_serializing_if = "Option::is_none")]
3755    pub max_results: Option<i32>,
3756    #[serde(rename = "NextToken")]
3757    #[serde(default)]
3758    #[serde(skip_serializing_if = "Option::is_none")]
3759    pub next_token: Option<String>,
3760}
3761
3762#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3763pub struct ListRecoveryPointsByBackupVaultOutput {
3764    #[serde(rename = "NextToken")]
3765    #[serde(default)]
3766    #[serde(skip_serializing_if = "Option::is_none")]
3767    pub next_token: Option<String>,
3768    #[serde(rename = "RecoveryPoints")]
3769    #[serde(default)]
3770    #[serde(skip_serializing_if = "Option::is_none")]
3771    pub recovery_points: Option<Vec<RecoveryPointByBackupVault>>,
3772}
3773
3774#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3775pub struct RecoveryPointByBackupVault {
3776    #[serde(rename = "AggregatedScanResult")]
3777    #[serde(default)]
3778    #[serde(skip_serializing_if = "Option::is_none")]
3779    pub aggregated_scan_result: Option<AggregatedScanResult>,
3780    #[serde(rename = "BackupSizeInBytes")]
3781    #[serde(default)]
3782    #[serde(skip_serializing_if = "Option::is_none")]
3783    pub backup_size_in_bytes: Option<i64>,
3784    #[serde(rename = "BackupVaultArn")]
3785    #[serde(default)]
3786    #[serde(skip_serializing_if = "Option::is_none")]
3787    pub backup_vault_arn: Option<String>,
3788    #[serde(rename = "BackupVaultName")]
3789    #[serde(default)]
3790    #[serde(skip_serializing_if = "Option::is_none")]
3791    pub backup_vault_name: Option<String>,
3792    #[serde(rename = "CalculatedLifecycle")]
3793    #[serde(default)]
3794    #[serde(skip_serializing_if = "Option::is_none")]
3795    pub calculated_lifecycle: Option<CalculatedLifecycle>,
3796    #[serde(rename = "CompletionDate")]
3797    #[serde(default)]
3798    #[serde(skip_serializing_if = "Option::is_none")]
3799    pub completion_date: Option<f64>,
3800    #[serde(rename = "CompositeMemberIdentifier")]
3801    #[serde(default)]
3802    #[serde(skip_serializing_if = "Option::is_none")]
3803    pub composite_member_identifier: Option<String>,
3804    #[serde(rename = "CreatedBy")]
3805    #[serde(default)]
3806    #[serde(skip_serializing_if = "Option::is_none")]
3807    pub created_by: Option<RecoveryPointCreator>,
3808    #[serde(rename = "CreationDate")]
3809    #[serde(default)]
3810    #[serde(skip_serializing_if = "Option::is_none")]
3811    pub creation_date: Option<f64>,
3812    #[serde(rename = "EncryptionKeyArn")]
3813    #[serde(default)]
3814    #[serde(skip_serializing_if = "Option::is_none")]
3815    pub encryption_key_arn: Option<String>,
3816    #[serde(rename = "EncryptionKeyType")]
3817    #[serde(default)]
3818    #[serde(skip_serializing_if = "Option::is_none")]
3819    pub encryption_key_type: Option<String>,
3820    #[serde(rename = "IamRoleArn")]
3821    #[serde(default)]
3822    #[serde(skip_serializing_if = "Option::is_none")]
3823    pub iam_role_arn: Option<String>,
3824    #[serde(rename = "IndexStatus")]
3825    #[serde(default)]
3826    #[serde(skip_serializing_if = "Option::is_none")]
3827    pub index_status: Option<String>,
3828    #[serde(rename = "IndexStatusMessage")]
3829    #[serde(default)]
3830    #[serde(skip_serializing_if = "Option::is_none")]
3831    pub index_status_message: Option<String>,
3832    #[serde(rename = "InitiationDate")]
3833    #[serde(default)]
3834    #[serde(skip_serializing_if = "Option::is_none")]
3835    pub initiation_date: Option<f64>,
3836    #[serde(rename = "IsEncrypted")]
3837    #[serde(default)]
3838    #[serde(skip_serializing_if = "Option::is_none")]
3839    pub is_encrypted: Option<bool>,
3840    #[serde(rename = "IsParent")]
3841    #[serde(default)]
3842    #[serde(skip_serializing_if = "Option::is_none")]
3843    pub is_parent: Option<bool>,
3844    #[serde(rename = "LastRestoreTime")]
3845    #[serde(default)]
3846    #[serde(skip_serializing_if = "Option::is_none")]
3847    pub last_restore_time: Option<f64>,
3848    #[serde(rename = "Lifecycle")]
3849    #[serde(default)]
3850    #[serde(skip_serializing_if = "Option::is_none")]
3851    pub lifecycle: Option<Lifecycle>,
3852    #[serde(rename = "ParentRecoveryPointArn")]
3853    #[serde(default)]
3854    #[serde(skip_serializing_if = "Option::is_none")]
3855    pub parent_recovery_point_arn: Option<String>,
3856    #[serde(rename = "RecoveryPointArn")]
3857    #[serde(default)]
3858    #[serde(skip_serializing_if = "Option::is_none")]
3859    pub recovery_point_arn: Option<String>,
3860    #[serde(rename = "ResourceArn")]
3861    #[serde(default)]
3862    #[serde(skip_serializing_if = "Option::is_none")]
3863    pub resource_arn: Option<String>,
3864    #[serde(rename = "ResourceName")]
3865    #[serde(default)]
3866    #[serde(skip_serializing_if = "Option::is_none")]
3867    pub resource_name: Option<String>,
3868    #[serde(rename = "ResourceType")]
3869    #[serde(default)]
3870    #[serde(skip_serializing_if = "Option::is_none")]
3871    pub resource_type: Option<String>,
3872    #[serde(rename = "SourceBackupVaultArn")]
3873    #[serde(default)]
3874    #[serde(skip_serializing_if = "Option::is_none")]
3875    pub source_backup_vault_arn: Option<String>,
3876    #[serde(rename = "Status")]
3877    #[serde(default)]
3878    #[serde(skip_serializing_if = "Option::is_none")]
3879    pub status: Option<String>,
3880    #[serde(rename = "StatusMessage")]
3881    #[serde(default)]
3882    #[serde(skip_serializing_if = "Option::is_none")]
3883    pub status_message: Option<String>,
3884    #[serde(rename = "VaultType")]
3885    #[serde(default)]
3886    #[serde(skip_serializing_if = "Option::is_none")]
3887    pub vault_type: Option<String>,
3888}
3889
3890#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3891pub struct AggregatedScanResult {
3892    #[serde(rename = "FailedScan")]
3893    #[serde(default)]
3894    #[serde(skip_serializing_if = "Option::is_none")]
3895    pub failed_scan: Option<bool>,
3896    #[serde(rename = "Findings")]
3897    #[serde(default)]
3898    #[serde(skip_serializing_if = "Option::is_none")]
3899    pub findings: Option<Vec<String>>,
3900    #[serde(rename = "LastComputed")]
3901    #[serde(default)]
3902    #[serde(skip_serializing_if = "Option::is_none")]
3903    pub last_computed: Option<f64>,
3904}
3905
3906#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3907pub struct ListRecoveryPointsByLegalHoldInput {
3908    #[serde(rename = "LegalHoldId")]
3909    #[serde(default)]
3910    pub legal_hold_id: String,
3911    #[serde(rename = "MaxResults")]
3912    #[serde(default)]
3913    #[serde(skip_serializing_if = "Option::is_none")]
3914    pub max_results: Option<i32>,
3915    #[serde(rename = "NextToken")]
3916    #[serde(default)]
3917    #[serde(skip_serializing_if = "Option::is_none")]
3918    pub next_token: Option<String>,
3919}
3920
3921#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3922pub struct ListRecoveryPointsByLegalHoldOutput {
3923    #[serde(rename = "NextToken")]
3924    #[serde(default)]
3925    #[serde(skip_serializing_if = "Option::is_none")]
3926    pub next_token: Option<String>,
3927    #[serde(rename = "RecoveryPoints")]
3928    #[serde(default)]
3929    #[serde(skip_serializing_if = "Option::is_none")]
3930    pub recovery_points: Option<Vec<RecoveryPointMember>>,
3931}
3932
3933#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3934pub struct RecoveryPointMember {
3935    #[serde(rename = "BackupVaultName")]
3936    #[serde(default)]
3937    #[serde(skip_serializing_if = "Option::is_none")]
3938    pub backup_vault_name: Option<String>,
3939    #[serde(rename = "RecoveryPointArn")]
3940    #[serde(default)]
3941    #[serde(skip_serializing_if = "Option::is_none")]
3942    pub recovery_point_arn: Option<String>,
3943    #[serde(rename = "ResourceArn")]
3944    #[serde(default)]
3945    #[serde(skip_serializing_if = "Option::is_none")]
3946    pub resource_arn: Option<String>,
3947    #[serde(rename = "ResourceType")]
3948    #[serde(default)]
3949    #[serde(skip_serializing_if = "Option::is_none")]
3950    pub resource_type: Option<String>,
3951}
3952
3953#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3954pub struct ListRecoveryPointsByResourceInput {
3955    #[serde(rename = "ManagedByAWSBackupOnly")]
3956    #[serde(default)]
3957    #[serde(skip_serializing_if = "Option::is_none")]
3958    pub managed_by_a_w_s_backup_only: Option<bool>,
3959    #[serde(rename = "MaxResults")]
3960    #[serde(default)]
3961    #[serde(skip_serializing_if = "Option::is_none")]
3962    pub max_results: Option<i32>,
3963    #[serde(rename = "NextToken")]
3964    #[serde(default)]
3965    #[serde(skip_serializing_if = "Option::is_none")]
3966    pub next_token: Option<String>,
3967    #[serde(rename = "ResourceArn")]
3968    #[serde(default)]
3969    pub resource_arn: String,
3970}
3971
3972#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3973pub struct ListRecoveryPointsByResourceOutput {
3974    #[serde(rename = "NextToken")]
3975    #[serde(default)]
3976    #[serde(skip_serializing_if = "Option::is_none")]
3977    pub next_token: Option<String>,
3978    #[serde(rename = "RecoveryPoints")]
3979    #[serde(default)]
3980    #[serde(skip_serializing_if = "Option::is_none")]
3981    pub recovery_points: Option<Vec<RecoveryPointByResource>>,
3982}
3983
3984#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3985pub struct RecoveryPointByResource {
3986    #[serde(rename = "AggregatedScanResult")]
3987    #[serde(default)]
3988    #[serde(skip_serializing_if = "Option::is_none")]
3989    pub aggregated_scan_result: Option<AggregatedScanResult>,
3990    #[serde(rename = "BackupSizeBytes")]
3991    #[serde(default)]
3992    #[serde(skip_serializing_if = "Option::is_none")]
3993    pub backup_size_bytes: Option<i64>,
3994    #[serde(rename = "BackupVaultName")]
3995    #[serde(default)]
3996    #[serde(skip_serializing_if = "Option::is_none")]
3997    pub backup_vault_name: Option<String>,
3998    #[serde(rename = "CreationDate")]
3999    #[serde(default)]
4000    #[serde(skip_serializing_if = "Option::is_none")]
4001    pub creation_date: Option<f64>,
4002    #[serde(rename = "EncryptionKeyArn")]
4003    #[serde(default)]
4004    #[serde(skip_serializing_if = "Option::is_none")]
4005    pub encryption_key_arn: Option<String>,
4006    #[serde(rename = "EncryptionKeyType")]
4007    #[serde(default)]
4008    #[serde(skip_serializing_if = "Option::is_none")]
4009    pub encryption_key_type: Option<String>,
4010    #[serde(rename = "IndexStatus")]
4011    #[serde(default)]
4012    #[serde(skip_serializing_if = "Option::is_none")]
4013    pub index_status: Option<String>,
4014    #[serde(rename = "IndexStatusMessage")]
4015    #[serde(default)]
4016    #[serde(skip_serializing_if = "Option::is_none")]
4017    pub index_status_message: Option<String>,
4018    #[serde(rename = "IsParent")]
4019    #[serde(default)]
4020    #[serde(skip_serializing_if = "Option::is_none")]
4021    pub is_parent: Option<bool>,
4022    #[serde(rename = "ParentRecoveryPointArn")]
4023    #[serde(default)]
4024    #[serde(skip_serializing_if = "Option::is_none")]
4025    pub parent_recovery_point_arn: Option<String>,
4026    #[serde(rename = "RecoveryPointArn")]
4027    #[serde(default)]
4028    #[serde(skip_serializing_if = "Option::is_none")]
4029    pub recovery_point_arn: Option<String>,
4030    #[serde(rename = "ResourceName")]
4031    #[serde(default)]
4032    #[serde(skip_serializing_if = "Option::is_none")]
4033    pub resource_name: Option<String>,
4034    #[serde(rename = "Status")]
4035    #[serde(default)]
4036    #[serde(skip_serializing_if = "Option::is_none")]
4037    pub status: Option<String>,
4038    #[serde(rename = "StatusMessage")]
4039    #[serde(default)]
4040    #[serde(skip_serializing_if = "Option::is_none")]
4041    pub status_message: Option<String>,
4042    #[serde(rename = "VaultType")]
4043    #[serde(default)]
4044    #[serde(skip_serializing_if = "Option::is_none")]
4045    pub vault_type: Option<String>,
4046}
4047
4048#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4049pub struct ListReportJobsInput {
4050    #[serde(rename = "ByCreationAfter")]
4051    #[serde(default)]
4052    #[serde(skip_serializing_if = "Option::is_none")]
4053    pub by_creation_after: Option<f64>,
4054    #[serde(rename = "ByCreationBefore")]
4055    #[serde(default)]
4056    #[serde(skip_serializing_if = "Option::is_none")]
4057    pub by_creation_before: Option<f64>,
4058    #[serde(rename = "ByReportPlanName")]
4059    #[serde(default)]
4060    #[serde(skip_serializing_if = "Option::is_none")]
4061    pub by_report_plan_name: Option<String>,
4062    #[serde(rename = "ByStatus")]
4063    #[serde(default)]
4064    #[serde(skip_serializing_if = "Option::is_none")]
4065    pub by_status: Option<String>,
4066    #[serde(rename = "MaxResults")]
4067    #[serde(default)]
4068    #[serde(skip_serializing_if = "Option::is_none")]
4069    pub max_results: Option<i32>,
4070    #[serde(rename = "NextToken")]
4071    #[serde(default)]
4072    #[serde(skip_serializing_if = "Option::is_none")]
4073    pub next_token: Option<String>,
4074}
4075
4076#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4077pub struct ListReportJobsOutput {
4078    #[serde(rename = "NextToken")]
4079    #[serde(default)]
4080    #[serde(skip_serializing_if = "Option::is_none")]
4081    pub next_token: Option<String>,
4082    #[serde(rename = "ReportJobs")]
4083    #[serde(default)]
4084    #[serde(skip_serializing_if = "Option::is_none")]
4085    pub report_jobs: Option<Vec<ReportJob>>,
4086}
4087
4088#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4089pub struct ListReportPlansInput {
4090    #[serde(rename = "MaxResults")]
4091    #[serde(default)]
4092    #[serde(skip_serializing_if = "Option::is_none")]
4093    pub max_results: Option<i32>,
4094    #[serde(rename = "NextToken")]
4095    #[serde(default)]
4096    #[serde(skip_serializing_if = "Option::is_none")]
4097    pub next_token: Option<String>,
4098}
4099
4100#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4101pub struct ListReportPlansOutput {
4102    #[serde(rename = "NextToken")]
4103    #[serde(default)]
4104    #[serde(skip_serializing_if = "Option::is_none")]
4105    pub next_token: Option<String>,
4106    #[serde(rename = "ReportPlans")]
4107    #[serde(default)]
4108    #[serde(skip_serializing_if = "Option::is_none")]
4109    pub report_plans: Option<Vec<ReportPlan>>,
4110}
4111
4112#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4113pub struct ListRestoreAccessBackupVaultsInput {
4114    #[serde(rename = "BackupVaultName")]
4115    #[serde(default)]
4116    pub backup_vault_name: String,
4117    #[serde(rename = "MaxResults")]
4118    #[serde(default)]
4119    #[serde(skip_serializing_if = "Option::is_none")]
4120    pub max_results: Option<i32>,
4121    #[serde(rename = "NextToken")]
4122    #[serde(default)]
4123    #[serde(skip_serializing_if = "Option::is_none")]
4124    pub next_token: Option<String>,
4125}
4126
4127#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4128pub struct ListRestoreAccessBackupVaultsOutput {
4129    #[serde(rename = "NextToken")]
4130    #[serde(default)]
4131    #[serde(skip_serializing_if = "Option::is_none")]
4132    pub next_token: Option<String>,
4133    #[serde(rename = "RestoreAccessBackupVaults")]
4134    #[serde(default)]
4135    #[serde(skip_serializing_if = "Option::is_none")]
4136    pub restore_access_backup_vaults: Option<Vec<RestoreAccessBackupVaultListMember>>,
4137}
4138
4139#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4140pub struct RestoreAccessBackupVaultListMember {
4141    #[serde(rename = "ApprovalDate")]
4142    #[serde(default)]
4143    #[serde(skip_serializing_if = "Option::is_none")]
4144    pub approval_date: Option<f64>,
4145    #[serde(rename = "CreationDate")]
4146    #[serde(default)]
4147    #[serde(skip_serializing_if = "Option::is_none")]
4148    pub creation_date: Option<f64>,
4149    #[serde(rename = "LatestRevokeRequest")]
4150    #[serde(default)]
4151    #[serde(skip_serializing_if = "Option::is_none")]
4152    pub latest_revoke_request: Option<LatestRevokeRequest>,
4153    #[serde(rename = "RestoreAccessBackupVaultArn")]
4154    #[serde(default)]
4155    #[serde(skip_serializing_if = "Option::is_none")]
4156    pub restore_access_backup_vault_arn: Option<String>,
4157    #[serde(rename = "VaultState")]
4158    #[serde(default)]
4159    #[serde(skip_serializing_if = "Option::is_none")]
4160    pub vault_state: Option<String>,
4161}
4162
4163#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4164pub struct LatestRevokeRequest {
4165    #[serde(rename = "ExpiryDate")]
4166    #[serde(default)]
4167    #[serde(skip_serializing_if = "Option::is_none")]
4168    pub expiry_date: Option<f64>,
4169    #[serde(rename = "InitiationDate")]
4170    #[serde(default)]
4171    #[serde(skip_serializing_if = "Option::is_none")]
4172    pub initiation_date: Option<f64>,
4173    #[serde(rename = "MpaSessionArn")]
4174    #[serde(default)]
4175    #[serde(skip_serializing_if = "Option::is_none")]
4176    pub mpa_session_arn: Option<String>,
4177    #[serde(rename = "Status")]
4178    #[serde(default)]
4179    #[serde(skip_serializing_if = "Option::is_none")]
4180    pub status: Option<String>,
4181    #[serde(rename = "StatusMessage")]
4182    #[serde(default)]
4183    #[serde(skip_serializing_if = "Option::is_none")]
4184    pub status_message: Option<String>,
4185}
4186
4187#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4188pub struct ListRestoreJobSummariesInput {
4189    #[serde(rename = "AccountId")]
4190    #[serde(default)]
4191    #[serde(skip_serializing_if = "Option::is_none")]
4192    pub account_id: Option<String>,
4193    #[serde(rename = "AggregationPeriod")]
4194    #[serde(default)]
4195    #[serde(skip_serializing_if = "Option::is_none")]
4196    pub aggregation_period: Option<String>,
4197    #[serde(rename = "MaxResults")]
4198    #[serde(default)]
4199    #[serde(skip_serializing_if = "Option::is_none")]
4200    pub max_results: Option<i32>,
4201    #[serde(rename = "NextToken")]
4202    #[serde(default)]
4203    #[serde(skip_serializing_if = "Option::is_none")]
4204    pub next_token: Option<String>,
4205    #[serde(rename = "ResourceType")]
4206    #[serde(default)]
4207    #[serde(skip_serializing_if = "Option::is_none")]
4208    pub resource_type: Option<String>,
4209    #[serde(rename = "State")]
4210    #[serde(default)]
4211    #[serde(skip_serializing_if = "Option::is_none")]
4212    pub state: Option<String>,
4213}
4214
4215#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4216pub struct ListRestoreJobSummariesOutput {
4217    #[serde(rename = "AggregationPeriod")]
4218    #[serde(default)]
4219    #[serde(skip_serializing_if = "Option::is_none")]
4220    pub aggregation_period: Option<String>,
4221    #[serde(rename = "NextToken")]
4222    #[serde(default)]
4223    #[serde(skip_serializing_if = "Option::is_none")]
4224    pub next_token: Option<String>,
4225    #[serde(rename = "RestoreJobSummaries")]
4226    #[serde(default)]
4227    #[serde(skip_serializing_if = "Option::is_none")]
4228    pub restore_job_summaries: Option<Vec<RestoreJobSummary>>,
4229}
4230
4231#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4232pub struct RestoreJobSummary {
4233    #[serde(rename = "AccountId")]
4234    #[serde(default)]
4235    #[serde(skip_serializing_if = "Option::is_none")]
4236    pub account_id: Option<String>,
4237    #[serde(rename = "Count")]
4238    #[serde(default)]
4239    #[serde(skip_serializing_if = "Option::is_none")]
4240    pub count: Option<i32>,
4241    #[serde(rename = "EndTime")]
4242    #[serde(default)]
4243    #[serde(skip_serializing_if = "Option::is_none")]
4244    pub end_time: Option<f64>,
4245    #[serde(rename = "Region")]
4246    #[serde(default)]
4247    #[serde(skip_serializing_if = "Option::is_none")]
4248    pub region: Option<String>,
4249    #[serde(rename = "ResourceType")]
4250    #[serde(default)]
4251    #[serde(skip_serializing_if = "Option::is_none")]
4252    pub resource_type: Option<String>,
4253    #[serde(rename = "StartTime")]
4254    #[serde(default)]
4255    #[serde(skip_serializing_if = "Option::is_none")]
4256    pub start_time: Option<f64>,
4257    #[serde(rename = "State")]
4258    #[serde(default)]
4259    #[serde(skip_serializing_if = "Option::is_none")]
4260    pub state: Option<String>,
4261}
4262
4263#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4264pub struct ListRestoreJobsByProtectedResourceInput {
4265    #[serde(rename = "ByRecoveryPointCreationDateAfter")]
4266    #[serde(default)]
4267    #[serde(skip_serializing_if = "Option::is_none")]
4268    pub by_recovery_point_creation_date_after: Option<f64>,
4269    #[serde(rename = "ByRecoveryPointCreationDateBefore")]
4270    #[serde(default)]
4271    #[serde(skip_serializing_if = "Option::is_none")]
4272    pub by_recovery_point_creation_date_before: Option<f64>,
4273    #[serde(rename = "ByStatus")]
4274    #[serde(default)]
4275    #[serde(skip_serializing_if = "Option::is_none")]
4276    pub by_status: Option<String>,
4277    #[serde(rename = "MaxResults")]
4278    #[serde(default)]
4279    #[serde(skip_serializing_if = "Option::is_none")]
4280    pub max_results: Option<i32>,
4281    #[serde(rename = "NextToken")]
4282    #[serde(default)]
4283    #[serde(skip_serializing_if = "Option::is_none")]
4284    pub next_token: Option<String>,
4285    #[serde(rename = "ResourceArn")]
4286    #[serde(default)]
4287    pub resource_arn: String,
4288}
4289
4290#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4291pub struct ListRestoreJobsByProtectedResourceOutput {
4292    #[serde(rename = "NextToken")]
4293    #[serde(default)]
4294    #[serde(skip_serializing_if = "Option::is_none")]
4295    pub next_token: Option<String>,
4296    #[serde(rename = "RestoreJobs")]
4297    #[serde(default)]
4298    #[serde(skip_serializing_if = "Option::is_none")]
4299    pub restore_jobs: Option<Vec<RestoreJobsListMember>>,
4300}
4301
4302#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4303pub struct RestoreJobsListMember {
4304    #[serde(rename = "AccountId")]
4305    #[serde(default)]
4306    #[serde(skip_serializing_if = "Option::is_none")]
4307    pub account_id: Option<String>,
4308    #[serde(rename = "BackupSizeInBytes")]
4309    #[serde(default)]
4310    #[serde(skip_serializing_if = "Option::is_none")]
4311    pub backup_size_in_bytes: Option<i64>,
4312    #[serde(rename = "BackupVaultArn")]
4313    #[serde(default)]
4314    #[serde(skip_serializing_if = "Option::is_none")]
4315    pub backup_vault_arn: Option<String>,
4316    #[serde(rename = "CompletionDate")]
4317    #[serde(default)]
4318    #[serde(skip_serializing_if = "Option::is_none")]
4319    pub completion_date: Option<f64>,
4320    #[serde(rename = "CreatedBy")]
4321    #[serde(default)]
4322    #[serde(skip_serializing_if = "Option::is_none")]
4323    pub created_by: Option<RestoreJobCreator>,
4324    #[serde(rename = "CreatedResourceArn")]
4325    #[serde(default)]
4326    #[serde(skip_serializing_if = "Option::is_none")]
4327    pub created_resource_arn: Option<String>,
4328    #[serde(rename = "CreationDate")]
4329    #[serde(default)]
4330    #[serde(skip_serializing_if = "Option::is_none")]
4331    pub creation_date: Option<f64>,
4332    #[serde(rename = "DeletionStatus")]
4333    #[serde(default)]
4334    #[serde(skip_serializing_if = "Option::is_none")]
4335    pub deletion_status: Option<String>,
4336    #[serde(rename = "DeletionStatusMessage")]
4337    #[serde(default)]
4338    #[serde(skip_serializing_if = "Option::is_none")]
4339    pub deletion_status_message: Option<String>,
4340    #[serde(rename = "ExpectedCompletionTimeMinutes")]
4341    #[serde(default)]
4342    #[serde(skip_serializing_if = "Option::is_none")]
4343    pub expected_completion_time_minutes: Option<i64>,
4344    #[serde(rename = "IamRoleArn")]
4345    #[serde(default)]
4346    #[serde(skip_serializing_if = "Option::is_none")]
4347    pub iam_role_arn: Option<String>,
4348    #[serde(rename = "IsParent")]
4349    #[serde(default)]
4350    #[serde(skip_serializing_if = "Option::is_none")]
4351    pub is_parent: Option<bool>,
4352    #[serde(rename = "ParentJobId")]
4353    #[serde(default)]
4354    #[serde(skip_serializing_if = "Option::is_none")]
4355    pub parent_job_id: Option<String>,
4356    #[serde(rename = "PercentDone")]
4357    #[serde(default)]
4358    #[serde(skip_serializing_if = "Option::is_none")]
4359    pub percent_done: Option<String>,
4360    #[serde(rename = "RecoveryPointArn")]
4361    #[serde(default)]
4362    #[serde(skip_serializing_if = "Option::is_none")]
4363    pub recovery_point_arn: Option<String>,
4364    #[serde(rename = "RecoveryPointCreationDate")]
4365    #[serde(default)]
4366    #[serde(skip_serializing_if = "Option::is_none")]
4367    pub recovery_point_creation_date: Option<f64>,
4368    #[serde(rename = "ResourceType")]
4369    #[serde(default)]
4370    #[serde(skip_serializing_if = "Option::is_none")]
4371    pub resource_type: Option<String>,
4372    #[serde(rename = "RestoreJobId")]
4373    #[serde(default)]
4374    #[serde(skip_serializing_if = "Option::is_none")]
4375    pub restore_job_id: Option<String>,
4376    #[serde(rename = "SourceResourceArn")]
4377    #[serde(default)]
4378    #[serde(skip_serializing_if = "Option::is_none")]
4379    pub source_resource_arn: Option<String>,
4380    #[serde(rename = "Status")]
4381    #[serde(default)]
4382    #[serde(skip_serializing_if = "Option::is_none")]
4383    pub status: Option<String>,
4384    #[serde(rename = "StatusMessage")]
4385    #[serde(default)]
4386    #[serde(skip_serializing_if = "Option::is_none")]
4387    pub status_message: Option<String>,
4388    #[serde(rename = "ValidationStatus")]
4389    #[serde(default)]
4390    #[serde(skip_serializing_if = "Option::is_none")]
4391    pub validation_status: Option<String>,
4392    #[serde(rename = "ValidationStatusMessage")]
4393    #[serde(default)]
4394    #[serde(skip_serializing_if = "Option::is_none")]
4395    pub validation_status_message: Option<String>,
4396}
4397
4398#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4399pub struct ListRestoreJobsInput {
4400    #[serde(rename = "ByAccountId")]
4401    #[serde(default)]
4402    #[serde(skip_serializing_if = "Option::is_none")]
4403    pub by_account_id: Option<String>,
4404    #[serde(rename = "ByCompleteAfter")]
4405    #[serde(default)]
4406    #[serde(skip_serializing_if = "Option::is_none")]
4407    pub by_complete_after: Option<f64>,
4408    #[serde(rename = "ByCompleteBefore")]
4409    #[serde(default)]
4410    #[serde(skip_serializing_if = "Option::is_none")]
4411    pub by_complete_before: Option<f64>,
4412    #[serde(rename = "ByCreatedAfter")]
4413    #[serde(default)]
4414    #[serde(skip_serializing_if = "Option::is_none")]
4415    pub by_created_after: Option<f64>,
4416    #[serde(rename = "ByCreatedBefore")]
4417    #[serde(default)]
4418    #[serde(skip_serializing_if = "Option::is_none")]
4419    pub by_created_before: Option<f64>,
4420    #[serde(rename = "ByParentJobId")]
4421    #[serde(default)]
4422    #[serde(skip_serializing_if = "Option::is_none")]
4423    pub by_parent_job_id: Option<String>,
4424    #[serde(rename = "ByResourceType")]
4425    #[serde(default)]
4426    #[serde(skip_serializing_if = "Option::is_none")]
4427    pub by_resource_type: Option<String>,
4428    #[serde(rename = "ByRestoreTestingPlanArn")]
4429    #[serde(default)]
4430    #[serde(skip_serializing_if = "Option::is_none")]
4431    pub by_restore_testing_plan_arn: Option<String>,
4432    #[serde(rename = "ByStatus")]
4433    #[serde(default)]
4434    #[serde(skip_serializing_if = "Option::is_none")]
4435    pub by_status: Option<String>,
4436    #[serde(rename = "MaxResults")]
4437    #[serde(default)]
4438    #[serde(skip_serializing_if = "Option::is_none")]
4439    pub max_results: Option<i32>,
4440    #[serde(rename = "NextToken")]
4441    #[serde(default)]
4442    #[serde(skip_serializing_if = "Option::is_none")]
4443    pub next_token: Option<String>,
4444}
4445
4446#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4447pub struct ListRestoreJobsOutput {
4448    #[serde(rename = "NextToken")]
4449    #[serde(default)]
4450    #[serde(skip_serializing_if = "Option::is_none")]
4451    pub next_token: Option<String>,
4452    #[serde(rename = "RestoreJobs")]
4453    #[serde(default)]
4454    #[serde(skip_serializing_if = "Option::is_none")]
4455    pub restore_jobs: Option<Vec<RestoreJobsListMember>>,
4456}
4457
4458#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4459pub struct ListRestoreTestingPlansInput {
4460    #[serde(rename = "MaxResults")]
4461    #[serde(default)]
4462    #[serde(skip_serializing_if = "Option::is_none")]
4463    pub max_results: Option<i32>,
4464    #[serde(rename = "NextToken")]
4465    #[serde(default)]
4466    #[serde(skip_serializing_if = "Option::is_none")]
4467    pub next_token: Option<String>,
4468}
4469
4470#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4471pub struct ListRestoreTestingPlansOutput {
4472    #[serde(rename = "NextToken")]
4473    #[serde(default)]
4474    #[serde(skip_serializing_if = "Option::is_none")]
4475    pub next_token: Option<String>,
4476    #[serde(rename = "RestoreTestingPlans")]
4477    #[serde(default)]
4478    #[serde(skip_serializing_if = "Option::is_none")]
4479    pub restore_testing_plans: Option<Vec<RestoreTestingPlanForList>>,
4480}
4481
4482#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4483pub struct RestoreTestingPlanForList {
4484    #[serde(rename = "CreationTime")]
4485    #[serde(default)]
4486    #[serde(skip_serializing_if = "Option::is_none")]
4487    pub creation_time: Option<f64>,
4488    #[serde(rename = "LastExecutionTime")]
4489    #[serde(default)]
4490    #[serde(skip_serializing_if = "Option::is_none")]
4491    pub last_execution_time: Option<f64>,
4492    #[serde(rename = "LastUpdateTime")]
4493    #[serde(default)]
4494    #[serde(skip_serializing_if = "Option::is_none")]
4495    pub last_update_time: Option<f64>,
4496    #[serde(rename = "RestoreTestingPlanArn")]
4497    #[serde(default)]
4498    #[serde(skip_serializing_if = "Option::is_none")]
4499    pub restore_testing_plan_arn: Option<String>,
4500    #[serde(rename = "RestoreTestingPlanName")]
4501    #[serde(default)]
4502    #[serde(skip_serializing_if = "Option::is_none")]
4503    pub restore_testing_plan_name: Option<String>,
4504    #[serde(rename = "ScheduleExpression")]
4505    #[serde(default)]
4506    #[serde(skip_serializing_if = "Option::is_none")]
4507    pub schedule_expression: Option<String>,
4508    #[serde(rename = "ScheduleExpressionTimezone")]
4509    #[serde(default)]
4510    #[serde(skip_serializing_if = "Option::is_none")]
4511    pub schedule_expression_timezone: Option<String>,
4512    #[serde(rename = "StartWindowHours")]
4513    #[serde(default)]
4514    #[serde(skip_serializing_if = "Option::is_none")]
4515    pub start_window_hours: Option<i32>,
4516}
4517
4518#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4519pub struct ListRestoreTestingSelectionsInput {
4520    #[serde(rename = "MaxResults")]
4521    #[serde(default)]
4522    #[serde(skip_serializing_if = "Option::is_none")]
4523    pub max_results: Option<i32>,
4524    #[serde(rename = "NextToken")]
4525    #[serde(default)]
4526    #[serde(skip_serializing_if = "Option::is_none")]
4527    pub next_token: Option<String>,
4528    #[serde(rename = "RestoreTestingPlanName")]
4529    #[serde(default)]
4530    pub restore_testing_plan_name: String,
4531}
4532
4533#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4534pub struct ListRestoreTestingSelectionsOutput {
4535    #[serde(rename = "NextToken")]
4536    #[serde(default)]
4537    #[serde(skip_serializing_if = "Option::is_none")]
4538    pub next_token: Option<String>,
4539    #[serde(rename = "RestoreTestingSelections")]
4540    #[serde(default)]
4541    #[serde(skip_serializing_if = "Option::is_none")]
4542    pub restore_testing_selections: Option<Vec<RestoreTestingSelectionForList>>,
4543}
4544
4545#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4546pub struct RestoreTestingSelectionForList {
4547    #[serde(rename = "CreationTime")]
4548    #[serde(default)]
4549    #[serde(skip_serializing_if = "Option::is_none")]
4550    pub creation_time: Option<f64>,
4551    #[serde(rename = "IamRoleArn")]
4552    #[serde(default)]
4553    #[serde(skip_serializing_if = "Option::is_none")]
4554    pub iam_role_arn: Option<String>,
4555    #[serde(rename = "ProtectedResourceType")]
4556    #[serde(default)]
4557    #[serde(skip_serializing_if = "Option::is_none")]
4558    pub protected_resource_type: Option<String>,
4559    #[serde(rename = "RestoreTestingPlanName")]
4560    #[serde(default)]
4561    #[serde(skip_serializing_if = "Option::is_none")]
4562    pub restore_testing_plan_name: Option<String>,
4563    #[serde(rename = "RestoreTestingSelectionName")]
4564    #[serde(default)]
4565    #[serde(skip_serializing_if = "Option::is_none")]
4566    pub restore_testing_selection_name: Option<String>,
4567    #[serde(rename = "ValidationWindowHours")]
4568    #[serde(default)]
4569    #[serde(skip_serializing_if = "Option::is_none")]
4570    pub validation_window_hours: Option<i32>,
4571}
4572
4573#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4574pub struct ListScanJobSummariesInput {
4575    #[serde(rename = "AccountId")]
4576    #[serde(default)]
4577    #[serde(skip_serializing_if = "Option::is_none")]
4578    pub account_id: Option<String>,
4579    #[serde(rename = "AggregationPeriod")]
4580    #[serde(default)]
4581    #[serde(skip_serializing_if = "Option::is_none")]
4582    pub aggregation_period: Option<String>,
4583    #[serde(rename = "MalwareScanner")]
4584    #[serde(default)]
4585    #[serde(skip_serializing_if = "Option::is_none")]
4586    pub malware_scanner: Option<String>,
4587    #[serde(rename = "MaxResults")]
4588    #[serde(default)]
4589    #[serde(skip_serializing_if = "Option::is_none")]
4590    pub max_results: Option<i32>,
4591    #[serde(rename = "NextToken")]
4592    #[serde(default)]
4593    #[serde(skip_serializing_if = "Option::is_none")]
4594    pub next_token: Option<String>,
4595    #[serde(rename = "ResourceType")]
4596    #[serde(default)]
4597    #[serde(skip_serializing_if = "Option::is_none")]
4598    pub resource_type: Option<String>,
4599    #[serde(rename = "ScanResultStatus")]
4600    #[serde(default)]
4601    #[serde(skip_serializing_if = "Option::is_none")]
4602    pub scan_result_status: Option<String>,
4603    #[serde(rename = "State")]
4604    #[serde(default)]
4605    #[serde(skip_serializing_if = "Option::is_none")]
4606    pub state: Option<String>,
4607}
4608
4609#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4610pub struct ListScanJobSummariesOutput {
4611    #[serde(rename = "AggregationPeriod")]
4612    #[serde(default)]
4613    #[serde(skip_serializing_if = "Option::is_none")]
4614    pub aggregation_period: Option<String>,
4615    #[serde(rename = "NextToken")]
4616    #[serde(default)]
4617    #[serde(skip_serializing_if = "Option::is_none")]
4618    pub next_token: Option<String>,
4619    #[serde(rename = "ScanJobSummaries")]
4620    #[serde(default)]
4621    #[serde(skip_serializing_if = "Option::is_none")]
4622    pub scan_job_summaries: Option<Vec<ScanJobSummary>>,
4623}
4624
4625#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4626pub struct ScanJobSummary {
4627    #[serde(rename = "AccountId")]
4628    #[serde(default)]
4629    #[serde(skip_serializing_if = "Option::is_none")]
4630    pub account_id: Option<String>,
4631    #[serde(rename = "Count")]
4632    #[serde(default)]
4633    #[serde(skip_serializing_if = "Option::is_none")]
4634    pub count: Option<i32>,
4635    #[serde(rename = "EndTime")]
4636    #[serde(default)]
4637    #[serde(skip_serializing_if = "Option::is_none")]
4638    pub end_time: Option<f64>,
4639    #[serde(rename = "MalwareScanner")]
4640    #[serde(default)]
4641    #[serde(skip_serializing_if = "Option::is_none")]
4642    pub malware_scanner: Option<String>,
4643    #[serde(rename = "Region")]
4644    #[serde(default)]
4645    #[serde(skip_serializing_if = "Option::is_none")]
4646    pub region: Option<String>,
4647    #[serde(rename = "ResourceType")]
4648    #[serde(default)]
4649    #[serde(skip_serializing_if = "Option::is_none")]
4650    pub resource_type: Option<String>,
4651    #[serde(rename = "ScanResultStatus")]
4652    #[serde(default)]
4653    #[serde(skip_serializing_if = "Option::is_none")]
4654    pub scan_result_status: Option<String>,
4655    #[serde(rename = "StartTime")]
4656    #[serde(default)]
4657    #[serde(skip_serializing_if = "Option::is_none")]
4658    pub start_time: Option<f64>,
4659    #[serde(rename = "State")]
4660    #[serde(default)]
4661    #[serde(skip_serializing_if = "Option::is_none")]
4662    pub state: Option<String>,
4663}
4664
4665#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4666pub struct ListScanJobsInput {
4667    #[serde(rename = "ByAccountId")]
4668    #[serde(default)]
4669    #[serde(skip_serializing_if = "Option::is_none")]
4670    pub by_account_id: Option<String>,
4671    #[serde(rename = "ByBackupVaultName")]
4672    #[serde(default)]
4673    #[serde(skip_serializing_if = "Option::is_none")]
4674    pub by_backup_vault_name: Option<String>,
4675    #[serde(rename = "ByCompleteAfter")]
4676    #[serde(default)]
4677    #[serde(skip_serializing_if = "Option::is_none")]
4678    pub by_complete_after: Option<f64>,
4679    #[serde(rename = "ByCompleteBefore")]
4680    #[serde(default)]
4681    #[serde(skip_serializing_if = "Option::is_none")]
4682    pub by_complete_before: Option<f64>,
4683    #[serde(rename = "ByMalwareScanner")]
4684    #[serde(default)]
4685    #[serde(skip_serializing_if = "Option::is_none")]
4686    pub by_malware_scanner: Option<String>,
4687    #[serde(rename = "ByRecoveryPointArn")]
4688    #[serde(default)]
4689    #[serde(skip_serializing_if = "Option::is_none")]
4690    pub by_recovery_point_arn: Option<String>,
4691    #[serde(rename = "ByResourceArn")]
4692    #[serde(default)]
4693    #[serde(skip_serializing_if = "Option::is_none")]
4694    pub by_resource_arn: Option<String>,
4695    #[serde(rename = "ByResourceType")]
4696    #[serde(default)]
4697    #[serde(skip_serializing_if = "Option::is_none")]
4698    pub by_resource_type: Option<String>,
4699    #[serde(rename = "ByScanResultStatus")]
4700    #[serde(default)]
4701    #[serde(skip_serializing_if = "Option::is_none")]
4702    pub by_scan_result_status: Option<String>,
4703    #[serde(rename = "ByState")]
4704    #[serde(default)]
4705    #[serde(skip_serializing_if = "Option::is_none")]
4706    pub by_state: Option<String>,
4707    #[serde(rename = "MaxResults")]
4708    #[serde(default)]
4709    #[serde(skip_serializing_if = "Option::is_none")]
4710    pub max_results: Option<i32>,
4711    #[serde(rename = "NextToken")]
4712    #[serde(default)]
4713    #[serde(skip_serializing_if = "Option::is_none")]
4714    pub next_token: Option<String>,
4715}
4716
4717#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4718pub struct ListScanJobsOutput {
4719    #[serde(rename = "NextToken")]
4720    #[serde(default)]
4721    #[serde(skip_serializing_if = "Option::is_none")]
4722    pub next_token: Option<String>,
4723    #[serde(rename = "ScanJobs")]
4724    #[serde(default)]
4725    #[serde(skip_serializing_if = "Option::is_none")]
4726    pub scan_jobs: Option<Vec<ScanJob>>,
4727}
4728
4729#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4730pub struct ScanJob {
4731    #[serde(rename = "AccountId")]
4732    #[serde(default)]
4733    #[serde(skip_serializing_if = "Option::is_none")]
4734    pub account_id: Option<String>,
4735    #[serde(rename = "BackupVaultArn")]
4736    #[serde(default)]
4737    #[serde(skip_serializing_if = "Option::is_none")]
4738    pub backup_vault_arn: Option<String>,
4739    #[serde(rename = "BackupVaultName")]
4740    #[serde(default)]
4741    #[serde(skip_serializing_if = "Option::is_none")]
4742    pub backup_vault_name: Option<String>,
4743    #[serde(rename = "CompletionDate")]
4744    #[serde(default)]
4745    #[serde(skip_serializing_if = "Option::is_none")]
4746    pub completion_date: Option<f64>,
4747    #[serde(rename = "CreatedBy")]
4748    #[serde(default)]
4749    #[serde(skip_serializing_if = "Option::is_none")]
4750    pub created_by: Option<ScanJobCreator>,
4751    #[serde(rename = "CreationDate")]
4752    #[serde(default)]
4753    #[serde(skip_serializing_if = "Option::is_none")]
4754    pub creation_date: Option<f64>,
4755    #[serde(rename = "IamRoleArn")]
4756    #[serde(default)]
4757    #[serde(skip_serializing_if = "Option::is_none")]
4758    pub iam_role_arn: Option<String>,
4759    #[serde(rename = "MalwareScanner")]
4760    #[serde(default)]
4761    #[serde(skip_serializing_if = "Option::is_none")]
4762    pub malware_scanner: Option<String>,
4763    #[serde(rename = "RecoveryPointArn")]
4764    #[serde(default)]
4765    #[serde(skip_serializing_if = "Option::is_none")]
4766    pub recovery_point_arn: Option<String>,
4767    #[serde(rename = "ResourceArn")]
4768    #[serde(default)]
4769    #[serde(skip_serializing_if = "Option::is_none")]
4770    pub resource_arn: Option<String>,
4771    #[serde(rename = "ResourceName")]
4772    #[serde(default)]
4773    #[serde(skip_serializing_if = "Option::is_none")]
4774    pub resource_name: Option<String>,
4775    #[serde(rename = "ResourceType")]
4776    #[serde(default)]
4777    #[serde(skip_serializing_if = "Option::is_none")]
4778    pub resource_type: Option<String>,
4779    #[serde(rename = "ScanBaseRecoveryPointArn")]
4780    #[serde(default)]
4781    #[serde(skip_serializing_if = "Option::is_none")]
4782    pub scan_base_recovery_point_arn: Option<String>,
4783    #[serde(rename = "ScanId")]
4784    #[serde(default)]
4785    #[serde(skip_serializing_if = "Option::is_none")]
4786    pub scan_id: Option<String>,
4787    #[serde(rename = "ScanJobId")]
4788    #[serde(default)]
4789    #[serde(skip_serializing_if = "Option::is_none")]
4790    pub scan_job_id: Option<String>,
4791    #[serde(rename = "ScanMode")]
4792    #[serde(default)]
4793    #[serde(skip_serializing_if = "Option::is_none")]
4794    pub scan_mode: Option<String>,
4795    #[serde(rename = "ScanResult")]
4796    #[serde(default)]
4797    #[serde(skip_serializing_if = "Option::is_none")]
4798    pub scan_result: Option<ScanResultInfo>,
4799    #[serde(rename = "ScannerRoleArn")]
4800    #[serde(default)]
4801    #[serde(skip_serializing_if = "Option::is_none")]
4802    pub scanner_role_arn: Option<String>,
4803    #[serde(rename = "State")]
4804    #[serde(default)]
4805    #[serde(skip_serializing_if = "Option::is_none")]
4806    pub state: Option<String>,
4807    #[serde(rename = "StatusMessage")]
4808    #[serde(default)]
4809    #[serde(skip_serializing_if = "Option::is_none")]
4810    pub status_message: Option<String>,
4811}
4812
4813#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4814pub struct ListTagsInput {
4815    #[serde(rename = "MaxResults")]
4816    #[serde(default)]
4817    #[serde(skip_serializing_if = "Option::is_none")]
4818    pub max_results: Option<i32>,
4819    #[serde(rename = "NextToken")]
4820    #[serde(default)]
4821    #[serde(skip_serializing_if = "Option::is_none")]
4822    pub next_token: Option<String>,
4823    #[serde(rename = "ResourceArn")]
4824    #[serde(default)]
4825    pub resource_arn: String,
4826}
4827
4828#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4829pub struct ListTagsOutput {
4830    #[serde(rename = "NextToken")]
4831    #[serde(default)]
4832    #[serde(skip_serializing_if = "Option::is_none")]
4833    pub next_token: Option<String>,
4834    #[serde(rename = "Tags")]
4835    #[serde(default)]
4836    #[serde(skip_serializing_if = "Option::is_none")]
4837    pub tags: Option<std::collections::HashMap<String, String>>,
4838}
4839
4840#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4841pub struct ListTieringConfigurationsInput {
4842    #[serde(rename = "MaxResults")]
4843    #[serde(default)]
4844    #[serde(skip_serializing_if = "Option::is_none")]
4845    pub max_results: Option<i32>,
4846    #[serde(rename = "NextToken")]
4847    #[serde(default)]
4848    #[serde(skip_serializing_if = "Option::is_none")]
4849    pub next_token: Option<String>,
4850}
4851
4852#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4853pub struct ListTieringConfigurationsOutput {
4854    #[serde(rename = "NextToken")]
4855    #[serde(default)]
4856    #[serde(skip_serializing_if = "Option::is_none")]
4857    pub next_token: Option<String>,
4858    #[serde(rename = "TieringConfigurations")]
4859    #[serde(default)]
4860    #[serde(skip_serializing_if = "Option::is_none")]
4861    pub tiering_configurations: Option<Vec<TieringConfigurationsListMember>>,
4862}
4863
4864#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4865pub struct TieringConfigurationsListMember {
4866    #[serde(rename = "BackupVaultName")]
4867    #[serde(default)]
4868    #[serde(skip_serializing_if = "Option::is_none")]
4869    pub backup_vault_name: Option<String>,
4870    #[serde(rename = "CreationTime")]
4871    #[serde(default)]
4872    #[serde(skip_serializing_if = "Option::is_none")]
4873    pub creation_time: Option<f64>,
4874    #[serde(rename = "LastUpdatedTime")]
4875    #[serde(default)]
4876    #[serde(skip_serializing_if = "Option::is_none")]
4877    pub last_updated_time: Option<f64>,
4878    #[serde(rename = "TieringConfigurationArn")]
4879    #[serde(default)]
4880    #[serde(skip_serializing_if = "Option::is_none")]
4881    pub tiering_configuration_arn: Option<String>,
4882    #[serde(rename = "TieringConfigurationName")]
4883    #[serde(default)]
4884    #[serde(skip_serializing_if = "Option::is_none")]
4885    pub tiering_configuration_name: Option<String>,
4886}
4887
4888#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4889pub struct PutBackupVaultAccessPolicyInput {
4890    #[serde(rename = "BackupVaultName")]
4891    #[serde(default)]
4892    pub backup_vault_name: String,
4893    #[serde(rename = "Policy")]
4894    #[serde(default)]
4895    #[serde(skip_serializing_if = "Option::is_none")]
4896    pub policy: Option<String>,
4897}
4898
4899#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4900pub struct PutBackupVaultLockConfigurationInput {
4901    #[serde(rename = "BackupVaultName")]
4902    #[serde(default)]
4903    pub backup_vault_name: String,
4904    #[serde(rename = "ChangeableForDays")]
4905    #[serde(default)]
4906    #[serde(skip_serializing_if = "Option::is_none")]
4907    pub changeable_for_days: Option<i64>,
4908    #[serde(rename = "MaxRetentionDays")]
4909    #[serde(default)]
4910    #[serde(skip_serializing_if = "Option::is_none")]
4911    pub max_retention_days: Option<i64>,
4912    #[serde(rename = "MinRetentionDays")]
4913    #[serde(default)]
4914    #[serde(skip_serializing_if = "Option::is_none")]
4915    pub min_retention_days: Option<i64>,
4916}
4917
4918#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4919pub struct PutBackupVaultNotificationsInput {
4920    #[serde(rename = "BackupVaultEvents")]
4921    #[serde(default)]
4922    pub backup_vault_events: Vec<String>,
4923    #[serde(rename = "BackupVaultName")]
4924    #[serde(default)]
4925    pub backup_vault_name: String,
4926    #[serde(rename = "SNSTopicArn")]
4927    #[serde(default)]
4928    pub s_n_s_topic_arn: String,
4929}
4930
4931#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4932pub struct PutRestoreValidationResultInput {
4933    #[serde(rename = "RestoreJobId")]
4934    #[serde(default)]
4935    pub restore_job_id: String,
4936    #[serde(rename = "ValidationStatus")]
4937    #[serde(default)]
4938    pub validation_status: String,
4939    #[serde(rename = "ValidationStatusMessage")]
4940    #[serde(default)]
4941    #[serde(skip_serializing_if = "Option::is_none")]
4942    pub validation_status_message: Option<String>,
4943}
4944
4945#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4946pub struct RevokeRestoreAccessBackupVaultInput {
4947    #[serde(rename = "BackupVaultName")]
4948    #[serde(default)]
4949    pub backup_vault_name: String,
4950    #[serde(rename = "RequesterComment")]
4951    #[serde(default)]
4952    #[serde(skip_serializing_if = "Option::is_none")]
4953    pub requester_comment: Option<String>,
4954    #[serde(rename = "RestoreAccessBackupVaultArn")]
4955    #[serde(default)]
4956    pub restore_access_backup_vault_arn: String,
4957}
4958
4959#[derive(Debug, Clone, Default, Deserialize, Serialize)]
4960pub struct StartBackupJobInput {
4961    #[serde(rename = "BackupOptions")]
4962    #[serde(default)]
4963    #[serde(skip_serializing_if = "Option::is_none")]
4964    pub backup_options: Option<std::collections::HashMap<String, String>>,
4965    #[serde(rename = "BackupVaultName")]
4966    #[serde(default)]
4967    pub backup_vault_name: String,
4968    #[serde(rename = "CompleteWindowMinutes")]
4969    #[serde(default)]
4970    #[serde(skip_serializing_if = "Option::is_none")]
4971    pub complete_window_minutes: Option<i64>,
4972    #[serde(rename = "IamRoleArn")]
4973    #[serde(default)]
4974    pub iam_role_arn: String,
4975    #[serde(rename = "IdempotencyToken")]
4976    #[serde(default)]
4977    #[serde(skip_serializing_if = "Option::is_none")]
4978    pub idempotency_token: Option<String>,
4979    #[serde(rename = "Index")]
4980    #[serde(default)]
4981    #[serde(skip_serializing_if = "Option::is_none")]
4982    pub index: Option<String>,
4983    #[serde(rename = "Lifecycle")]
4984    #[serde(default)]
4985    #[serde(skip_serializing_if = "Option::is_none")]
4986    pub lifecycle: Option<Lifecycle>,
4987    #[serde(rename = "LogicallyAirGappedBackupVaultArn")]
4988    #[serde(default)]
4989    #[serde(skip_serializing_if = "Option::is_none")]
4990    pub logically_air_gapped_backup_vault_arn: Option<String>,
4991    #[serde(rename = "RecoveryPointTags")]
4992    #[serde(default)]
4993    #[serde(skip_serializing_if = "Option::is_none")]
4994    pub recovery_point_tags: Option<std::collections::HashMap<String, String>>,
4995    #[serde(rename = "ResourceArn")]
4996    #[serde(default)]
4997    pub resource_arn: String,
4998    #[serde(rename = "StartWindowMinutes")]
4999    #[serde(default)]
5000    #[serde(skip_serializing_if = "Option::is_none")]
5001    pub start_window_minutes: Option<i64>,
5002}
5003
5004#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5005pub struct StartBackupJobOutput {
5006    #[serde(rename = "BackupJobId")]
5007    #[serde(default)]
5008    #[serde(skip_serializing_if = "Option::is_none")]
5009    pub backup_job_id: Option<String>,
5010    #[serde(rename = "CreationDate")]
5011    #[serde(default)]
5012    #[serde(skip_serializing_if = "Option::is_none")]
5013    pub creation_date: Option<f64>,
5014    #[serde(rename = "IsParent")]
5015    #[serde(default)]
5016    #[serde(skip_serializing_if = "Option::is_none")]
5017    pub is_parent: Option<bool>,
5018    #[serde(rename = "RecoveryPointArn")]
5019    #[serde(default)]
5020    #[serde(skip_serializing_if = "Option::is_none")]
5021    pub recovery_point_arn: Option<String>,
5022}
5023
5024#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5025pub struct StartCopyJobInput {
5026    #[serde(rename = "DestinationBackupVaultArn")]
5027    #[serde(default)]
5028    pub destination_backup_vault_arn: String,
5029    #[serde(rename = "IamRoleArn")]
5030    #[serde(default)]
5031    pub iam_role_arn: String,
5032    #[serde(rename = "IdempotencyToken")]
5033    #[serde(default)]
5034    #[serde(skip_serializing_if = "Option::is_none")]
5035    pub idempotency_token: Option<String>,
5036    #[serde(rename = "Lifecycle")]
5037    #[serde(default)]
5038    #[serde(skip_serializing_if = "Option::is_none")]
5039    pub lifecycle: Option<Lifecycle>,
5040    #[serde(rename = "RecoveryPointArn")]
5041    #[serde(default)]
5042    pub recovery_point_arn: String,
5043    #[serde(rename = "SourceBackupVaultName")]
5044    #[serde(default)]
5045    pub source_backup_vault_name: String,
5046}
5047
5048#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5049pub struct StartCopyJobOutput {
5050    #[serde(rename = "CopyJobId")]
5051    #[serde(default)]
5052    #[serde(skip_serializing_if = "Option::is_none")]
5053    pub copy_job_id: Option<String>,
5054    #[serde(rename = "CreationDate")]
5055    #[serde(default)]
5056    #[serde(skip_serializing_if = "Option::is_none")]
5057    pub creation_date: Option<f64>,
5058    #[serde(rename = "IsParent")]
5059    #[serde(default)]
5060    #[serde(skip_serializing_if = "Option::is_none")]
5061    pub is_parent: Option<bool>,
5062}
5063
5064#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5065pub struct StartReportJobInput {
5066    #[serde(rename = "IdempotencyToken")]
5067    #[serde(default)]
5068    #[serde(skip_serializing_if = "Option::is_none")]
5069    pub idempotency_token: Option<String>,
5070    #[serde(rename = "ReportPlanName")]
5071    #[serde(default)]
5072    pub report_plan_name: String,
5073}
5074
5075#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5076pub struct StartReportJobOutput {
5077    #[serde(rename = "ReportJobId")]
5078    #[serde(default)]
5079    #[serde(skip_serializing_if = "Option::is_none")]
5080    pub report_job_id: Option<String>,
5081}
5082
5083#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5084pub struct StartRestoreJobInput {
5085    #[serde(rename = "CopySourceTagsToRestoredResource")]
5086    #[serde(default)]
5087    #[serde(skip_serializing_if = "Option::is_none")]
5088    pub copy_source_tags_to_restored_resource: Option<bool>,
5089    #[serde(rename = "IamRoleArn")]
5090    #[serde(default)]
5091    #[serde(skip_serializing_if = "Option::is_none")]
5092    pub iam_role_arn: Option<String>,
5093    #[serde(rename = "IdempotencyToken")]
5094    #[serde(default)]
5095    #[serde(skip_serializing_if = "Option::is_none")]
5096    pub idempotency_token: Option<String>,
5097    #[serde(rename = "Metadata")]
5098    #[serde(default)]
5099    pub metadata: std::collections::HashMap<String, String>,
5100    #[serde(rename = "RecoveryPointArn")]
5101    #[serde(default)]
5102    pub recovery_point_arn: String,
5103    #[serde(rename = "ResourceType")]
5104    #[serde(default)]
5105    #[serde(skip_serializing_if = "Option::is_none")]
5106    pub resource_type: Option<String>,
5107}
5108
5109#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5110pub struct StartRestoreJobOutput {
5111    #[serde(rename = "RestoreJobId")]
5112    #[serde(default)]
5113    #[serde(skip_serializing_if = "Option::is_none")]
5114    pub restore_job_id: Option<String>,
5115}
5116
5117#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5118pub struct StartScanJobInput {
5119    #[serde(rename = "BackupVaultName")]
5120    #[serde(default)]
5121    pub backup_vault_name: String,
5122    #[serde(rename = "IamRoleArn")]
5123    #[serde(default)]
5124    pub iam_role_arn: String,
5125    #[serde(rename = "IdempotencyToken")]
5126    #[serde(default)]
5127    #[serde(skip_serializing_if = "Option::is_none")]
5128    pub idempotency_token: Option<String>,
5129    #[serde(rename = "MalwareScanner")]
5130    #[serde(default)]
5131    pub malware_scanner: String,
5132    #[serde(rename = "RecoveryPointArn")]
5133    #[serde(default)]
5134    pub recovery_point_arn: String,
5135    #[serde(rename = "ScanBaseRecoveryPointArn")]
5136    #[serde(default)]
5137    #[serde(skip_serializing_if = "Option::is_none")]
5138    pub scan_base_recovery_point_arn: Option<String>,
5139    #[serde(rename = "ScanMode")]
5140    #[serde(default)]
5141    pub scan_mode: String,
5142    #[serde(rename = "ScannerRoleArn")]
5143    #[serde(default)]
5144    pub scanner_role_arn: String,
5145}
5146
5147#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5148pub struct StartScanJobOutput {
5149    #[serde(rename = "CreationDate")]
5150    #[serde(default)]
5151    #[serde(skip_serializing_if = "Option::is_none")]
5152    pub creation_date: Option<f64>,
5153    #[serde(rename = "ScanJobId")]
5154    #[serde(default)]
5155    #[serde(skip_serializing_if = "Option::is_none")]
5156    pub scan_job_id: Option<String>,
5157}
5158
5159#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5160pub struct StopBackupJobInput {
5161    #[serde(rename = "BackupJobId")]
5162    #[serde(default)]
5163    pub backup_job_id: String,
5164}
5165
5166#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5167pub struct TagResourceInput {
5168    #[serde(rename = "ResourceArn")]
5169    #[serde(default)]
5170    pub resource_arn: String,
5171    #[serde(rename = "Tags")]
5172    #[serde(default)]
5173    pub tags: std::collections::HashMap<String, String>,
5174}
5175
5176#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5177pub struct UntagResourceInput {
5178    #[serde(rename = "ResourceArn")]
5179    #[serde(default)]
5180    pub resource_arn: String,
5181    #[serde(rename = "TagKeyList")]
5182    #[serde(default)]
5183    pub tag_key_list: Vec<String>,
5184}
5185
5186#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5187pub struct UpdateBackupPlanInput {
5188    #[serde(rename = "BackupPlan")]
5189    #[serde(default)]
5190    pub backup_plan: BackupPlanInput,
5191    #[serde(rename = "BackupPlanId")]
5192    #[serde(default)]
5193    pub backup_plan_id: String,
5194}
5195
5196#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5197pub struct UpdateBackupPlanOutput {
5198    #[serde(rename = "AdvancedBackupSettings")]
5199    #[serde(default)]
5200    #[serde(skip_serializing_if = "Option::is_none")]
5201    pub advanced_backup_settings: Option<Vec<AdvancedBackupSetting>>,
5202    #[serde(rename = "BackupPlanArn")]
5203    #[serde(default)]
5204    #[serde(skip_serializing_if = "Option::is_none")]
5205    pub backup_plan_arn: Option<String>,
5206    #[serde(rename = "BackupPlanId")]
5207    #[serde(default)]
5208    #[serde(skip_serializing_if = "Option::is_none")]
5209    pub backup_plan_id: Option<String>,
5210    #[serde(rename = "CreationDate")]
5211    #[serde(default)]
5212    #[serde(skip_serializing_if = "Option::is_none")]
5213    pub creation_date: Option<f64>,
5214    #[serde(rename = "ScanSettings")]
5215    #[serde(default)]
5216    #[serde(skip_serializing_if = "Option::is_none")]
5217    pub scan_settings: Option<Vec<ScanSetting>>,
5218    #[serde(rename = "VersionId")]
5219    #[serde(default)]
5220    #[serde(skip_serializing_if = "Option::is_none")]
5221    pub version_id: Option<String>,
5222}
5223
5224#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5225pub struct UpdateFrameworkInput {
5226    #[serde(rename = "FrameworkControls")]
5227    #[serde(default)]
5228    #[serde(skip_serializing_if = "Option::is_none")]
5229    pub framework_controls: Option<Vec<FrameworkControl>>,
5230    #[serde(rename = "FrameworkDescription")]
5231    #[serde(default)]
5232    #[serde(skip_serializing_if = "Option::is_none")]
5233    pub framework_description: Option<String>,
5234    #[serde(rename = "FrameworkName")]
5235    #[serde(default)]
5236    pub framework_name: String,
5237    #[serde(rename = "IdempotencyToken")]
5238    #[serde(default)]
5239    #[serde(skip_serializing_if = "Option::is_none")]
5240    pub idempotency_token: Option<String>,
5241}
5242
5243#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5244pub struct UpdateFrameworkOutput {
5245    #[serde(rename = "CreationTime")]
5246    #[serde(default)]
5247    #[serde(skip_serializing_if = "Option::is_none")]
5248    pub creation_time: Option<f64>,
5249    #[serde(rename = "FrameworkArn")]
5250    #[serde(default)]
5251    #[serde(skip_serializing_if = "Option::is_none")]
5252    pub framework_arn: Option<String>,
5253    #[serde(rename = "FrameworkName")]
5254    #[serde(default)]
5255    #[serde(skip_serializing_if = "Option::is_none")]
5256    pub framework_name: Option<String>,
5257}
5258
5259#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5260pub struct UpdateGlobalSettingsInput {
5261    #[serde(rename = "GlobalSettings")]
5262    #[serde(default)]
5263    #[serde(skip_serializing_if = "Option::is_none")]
5264    pub global_settings: Option<std::collections::HashMap<String, String>>,
5265}
5266
5267#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5268pub struct UpdateRecoveryPointIndexSettingsInput {
5269    #[serde(rename = "BackupVaultName")]
5270    #[serde(default)]
5271    pub backup_vault_name: String,
5272    #[serde(rename = "IamRoleArn")]
5273    #[serde(default)]
5274    #[serde(skip_serializing_if = "Option::is_none")]
5275    pub iam_role_arn: Option<String>,
5276    #[serde(rename = "Index")]
5277    #[serde(default)]
5278    pub index: String,
5279    #[serde(rename = "RecoveryPointArn")]
5280    #[serde(default)]
5281    pub recovery_point_arn: String,
5282}
5283
5284#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5285pub struct UpdateRecoveryPointIndexSettingsOutput {
5286    #[serde(rename = "BackupVaultName")]
5287    #[serde(default)]
5288    #[serde(skip_serializing_if = "Option::is_none")]
5289    pub backup_vault_name: Option<String>,
5290    #[serde(rename = "Index")]
5291    #[serde(default)]
5292    #[serde(skip_serializing_if = "Option::is_none")]
5293    pub index: Option<String>,
5294    #[serde(rename = "IndexStatus")]
5295    #[serde(default)]
5296    #[serde(skip_serializing_if = "Option::is_none")]
5297    pub index_status: Option<String>,
5298    #[serde(rename = "RecoveryPointArn")]
5299    #[serde(default)]
5300    #[serde(skip_serializing_if = "Option::is_none")]
5301    pub recovery_point_arn: Option<String>,
5302}
5303
5304#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5305pub struct UpdateRecoveryPointLifecycleInput {
5306    #[serde(rename = "BackupVaultName")]
5307    #[serde(default)]
5308    pub backup_vault_name: String,
5309    #[serde(rename = "Lifecycle")]
5310    #[serde(default)]
5311    #[serde(skip_serializing_if = "Option::is_none")]
5312    pub lifecycle: Option<Lifecycle>,
5313    #[serde(rename = "RecoveryPointArn")]
5314    #[serde(default)]
5315    pub recovery_point_arn: String,
5316}
5317
5318#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5319pub struct UpdateRecoveryPointLifecycleOutput {
5320    #[serde(rename = "BackupVaultArn")]
5321    #[serde(default)]
5322    #[serde(skip_serializing_if = "Option::is_none")]
5323    pub backup_vault_arn: Option<String>,
5324    #[serde(rename = "CalculatedLifecycle")]
5325    #[serde(default)]
5326    #[serde(skip_serializing_if = "Option::is_none")]
5327    pub calculated_lifecycle: Option<CalculatedLifecycle>,
5328    #[serde(rename = "Lifecycle")]
5329    #[serde(default)]
5330    #[serde(skip_serializing_if = "Option::is_none")]
5331    pub lifecycle: Option<Lifecycle>,
5332    #[serde(rename = "RecoveryPointArn")]
5333    #[serde(default)]
5334    #[serde(skip_serializing_if = "Option::is_none")]
5335    pub recovery_point_arn: Option<String>,
5336}
5337
5338#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5339pub struct UpdateRegionSettingsInput {
5340    #[serde(rename = "ResourceTypeManagementPreference")]
5341    #[serde(default)]
5342    #[serde(skip_serializing_if = "Option::is_none")]
5343    pub resource_type_management_preference: Option<std::collections::HashMap<String, bool>>,
5344    #[serde(rename = "ResourceTypeOptInPreference")]
5345    #[serde(default)]
5346    #[serde(skip_serializing_if = "Option::is_none")]
5347    pub resource_type_opt_in_preference: Option<std::collections::HashMap<String, bool>>,
5348}
5349
5350#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5351pub struct UpdateReportPlanInput {
5352    #[serde(rename = "IdempotencyToken")]
5353    #[serde(default)]
5354    #[serde(skip_serializing_if = "Option::is_none")]
5355    pub idempotency_token: Option<String>,
5356    #[serde(rename = "ReportDeliveryChannel")]
5357    #[serde(default)]
5358    #[serde(skip_serializing_if = "Option::is_none")]
5359    pub report_delivery_channel: Option<ReportDeliveryChannel>,
5360    #[serde(rename = "ReportPlanDescription")]
5361    #[serde(default)]
5362    #[serde(skip_serializing_if = "Option::is_none")]
5363    pub report_plan_description: Option<String>,
5364    #[serde(rename = "ReportPlanName")]
5365    #[serde(default)]
5366    pub report_plan_name: String,
5367    #[serde(rename = "ReportSetting")]
5368    #[serde(default)]
5369    #[serde(skip_serializing_if = "Option::is_none")]
5370    pub report_setting: Option<ReportSetting>,
5371}
5372
5373#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5374pub struct UpdateReportPlanOutput {
5375    #[serde(rename = "CreationTime")]
5376    #[serde(default)]
5377    #[serde(skip_serializing_if = "Option::is_none")]
5378    pub creation_time: Option<f64>,
5379    #[serde(rename = "ReportPlanArn")]
5380    #[serde(default)]
5381    #[serde(skip_serializing_if = "Option::is_none")]
5382    pub report_plan_arn: Option<String>,
5383    #[serde(rename = "ReportPlanName")]
5384    #[serde(default)]
5385    #[serde(skip_serializing_if = "Option::is_none")]
5386    pub report_plan_name: Option<String>,
5387}
5388
5389#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5390pub struct UpdateRestoreTestingPlanInput {
5391    #[serde(rename = "RestoreTestingPlan")]
5392    #[serde(default)]
5393    pub restore_testing_plan: RestoreTestingPlanForUpdate,
5394    #[serde(rename = "RestoreTestingPlanName")]
5395    #[serde(default)]
5396    pub restore_testing_plan_name: String,
5397}
5398
5399#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5400pub struct RestoreTestingPlanForUpdate {
5401    #[serde(rename = "RecoveryPointSelection")]
5402    #[serde(default)]
5403    #[serde(skip_serializing_if = "Option::is_none")]
5404    pub recovery_point_selection: Option<RestoreTestingRecoveryPointSelection>,
5405    #[serde(rename = "ScheduleExpression")]
5406    #[serde(default)]
5407    #[serde(skip_serializing_if = "Option::is_none")]
5408    pub schedule_expression: Option<String>,
5409    #[serde(rename = "ScheduleExpressionTimezone")]
5410    #[serde(default)]
5411    #[serde(skip_serializing_if = "Option::is_none")]
5412    pub schedule_expression_timezone: Option<String>,
5413    #[serde(rename = "StartWindowHours")]
5414    #[serde(default)]
5415    #[serde(skip_serializing_if = "Option::is_none")]
5416    pub start_window_hours: Option<i32>,
5417}
5418
5419#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5420pub struct UpdateRestoreTestingPlanOutput {
5421    #[serde(rename = "CreationTime")]
5422    #[serde(default)]
5423    #[serde(skip_serializing_if = "Option::is_none")]
5424    pub creation_time: Option<f64>,
5425    #[serde(rename = "RestoreTestingPlanArn")]
5426    #[serde(default)]
5427    #[serde(skip_serializing_if = "Option::is_none")]
5428    pub restore_testing_plan_arn: Option<String>,
5429    #[serde(rename = "RestoreTestingPlanName")]
5430    #[serde(default)]
5431    #[serde(skip_serializing_if = "Option::is_none")]
5432    pub restore_testing_plan_name: Option<String>,
5433    #[serde(rename = "UpdateTime")]
5434    #[serde(default)]
5435    #[serde(skip_serializing_if = "Option::is_none")]
5436    pub update_time: Option<f64>,
5437}
5438
5439#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5440pub struct UpdateRestoreTestingSelectionInput {
5441    #[serde(rename = "RestoreTestingPlanName")]
5442    #[serde(default)]
5443    pub restore_testing_plan_name: String,
5444    #[serde(rename = "RestoreTestingSelection")]
5445    #[serde(default)]
5446    pub restore_testing_selection: RestoreTestingSelectionForUpdate,
5447    #[serde(rename = "RestoreTestingSelectionName")]
5448    #[serde(default)]
5449    pub restore_testing_selection_name: String,
5450}
5451
5452#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5453pub struct RestoreTestingSelectionForUpdate {
5454    #[serde(rename = "IamRoleArn")]
5455    #[serde(default)]
5456    #[serde(skip_serializing_if = "Option::is_none")]
5457    pub iam_role_arn: Option<String>,
5458    #[serde(rename = "ProtectedResourceArns")]
5459    #[serde(default)]
5460    #[serde(skip_serializing_if = "Option::is_none")]
5461    pub protected_resource_arns: Option<Vec<String>>,
5462    #[serde(rename = "ProtectedResourceConditions")]
5463    #[serde(default)]
5464    #[serde(skip_serializing_if = "Option::is_none")]
5465    pub protected_resource_conditions: Option<ProtectedResourceConditions>,
5466    #[serde(rename = "RestoreMetadataOverrides")]
5467    #[serde(default)]
5468    #[serde(skip_serializing_if = "Option::is_none")]
5469    pub restore_metadata_overrides: Option<std::collections::HashMap<String, String>>,
5470    #[serde(rename = "ValidationWindowHours")]
5471    #[serde(default)]
5472    #[serde(skip_serializing_if = "Option::is_none")]
5473    pub validation_window_hours: Option<i32>,
5474}
5475
5476#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5477pub struct UpdateRestoreTestingSelectionOutput {
5478    #[serde(rename = "CreationTime")]
5479    #[serde(default)]
5480    #[serde(skip_serializing_if = "Option::is_none")]
5481    pub creation_time: Option<f64>,
5482    #[serde(rename = "RestoreTestingPlanArn")]
5483    #[serde(default)]
5484    #[serde(skip_serializing_if = "Option::is_none")]
5485    pub restore_testing_plan_arn: Option<String>,
5486    #[serde(rename = "RestoreTestingPlanName")]
5487    #[serde(default)]
5488    #[serde(skip_serializing_if = "Option::is_none")]
5489    pub restore_testing_plan_name: Option<String>,
5490    #[serde(rename = "RestoreTestingSelectionName")]
5491    #[serde(default)]
5492    #[serde(skip_serializing_if = "Option::is_none")]
5493    pub restore_testing_selection_name: Option<String>,
5494    #[serde(rename = "UpdateTime")]
5495    #[serde(default)]
5496    #[serde(skip_serializing_if = "Option::is_none")]
5497    pub update_time: Option<f64>,
5498}
5499
5500#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5501pub struct UpdateTieringConfigurationInput {
5502    #[serde(rename = "TieringConfiguration")]
5503    #[serde(default)]
5504    pub tiering_configuration: TieringConfigurationInputForUpdate,
5505    #[serde(rename = "TieringConfigurationName")]
5506    #[serde(default)]
5507    pub tiering_configuration_name: String,
5508}
5509
5510#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5511pub struct TieringConfigurationInputForUpdate {
5512    #[serde(rename = "BackupVaultName")]
5513    #[serde(default)]
5514    pub backup_vault_name: String,
5515    #[serde(rename = "ResourceSelection")]
5516    #[serde(default)]
5517    pub resource_selection: Vec<ResourceSelection>,
5518}
5519
5520#[derive(Debug, Clone, Default, Deserialize, Serialize)]
5521pub struct UpdateTieringConfigurationOutput {
5522    #[serde(rename = "CreationTime")]
5523    #[serde(default)]
5524    #[serde(skip_serializing_if = "Option::is_none")]
5525    pub creation_time: Option<f64>,
5526    #[serde(rename = "LastUpdatedTime")]
5527    #[serde(default)]
5528    #[serde(skip_serializing_if = "Option::is_none")]
5529    pub last_updated_time: Option<f64>,
5530    #[serde(rename = "TieringConfigurationArn")]
5531    #[serde(default)]
5532    #[serde(skip_serializing_if = "Option::is_none")]
5533    pub tiering_configuration_arn: Option<String>,
5534    #[serde(rename = "TieringConfigurationName")]
5535    #[serde(default)]
5536    #[serde(skip_serializing_if = "Option::is_none")]
5537    pub tiering_configuration_name: Option<String>,
5538}