0
# Backup and Restore
1
2
Comprehensive backup and restore capabilities including on-demand backups and point-in-time recovery. DynamoDB provides multiple options for protecting your data and enabling disaster recovery scenarios.
3
4
## Capabilities
5
6
### Create Backup
7
8
Creates an on-demand backup of a DynamoDB table.
9
10
```java { .api }
11
/**
12
* Creates a backup for an existing table
13
* @param request - The request containing table name and backup name
14
* @return Response containing backup details
15
*/
16
CreateBackupResponse createBackup(CreateBackupRequest request);
17
18
class CreateBackupRequest {
19
static Builder builder();
20
21
/** The name of the table to back up */
22
String tableName();
23
Builder tableName(String tableName);
24
25
/** Specified name for the backup */
26
String backupName();
27
Builder backupName(String backupName);
28
}
29
30
class CreateBackupResponse {
31
/** Contains the details of the backup created for the table */
32
BackupDetails backupDetails();
33
}
34
35
class BackupDetails {
36
/** ARN associated with the backup */
37
String backupArn();
38
39
/** Name of the requested backup */
40
String backupName();
41
42
/** Size of the backup in bytes */
43
Long backupSizeBytes();
44
45
/** Backup can be in one of the following states: CREATING, DELETED, AVAILABLE */
46
BackupStatus backupStatus();
47
48
/** BackupType: USER for user-initiated backup. SYSTEM for system-initiated backup */
49
BackupType backupType();
50
51
/** Time at which the backup was created */
52
Instant backupCreationDateTime();
53
54
/** Time at which the automatic on-demand backup created by DynamoDB will expire */
55
Instant backupExpiryDateTime();
56
}
57
```
58
59
**Usage Example:**
60
61
```java
62
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
63
import software.amazon.awssdk.services.dynamodb.model.*;
64
import java.time.LocalDateTime;
65
import java.time.format.DateTimeFormatter;
66
67
DynamoDbClient client = DynamoDbClient.builder().build();
68
69
// Create a backup with timestamp in name
70
String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd-HH-mm"));
71
String backupName = "Orders-backup-" + timestamp;
72
73
CreateBackupResponse response = client.createBackup(CreateBackupRequest.builder()
74
.tableName("Orders")
75
.backupName(backupName)
76
.build());
77
78
BackupDetails backup = response.backupDetails();
79
System.out.println("Backup created: " + backup.backupName());
80
System.out.println("ARN: " + backup.backupArn());
81
System.out.println("Status: " + backup.backupStatus());
82
System.out.println("Size: " + backup.backupSizeBytes() + " bytes");
83
System.out.println("Created: " + backup.backupCreationDateTime());
84
```
85
86
### Describe Backup
87
88
Retrieves information about a specific backup.
89
90
```java { .api }
91
/**
92
* Describes an existing backup of a table
93
* @param request - The request containing backup ARN
94
* @return Response containing backup description
95
*/
96
DescribeBackupResponse describeBackup(DescribeBackupRequest request);
97
98
class DescribeBackupRequest {
99
static Builder builder();
100
101
/** The Amazon Resource Name (ARN) associated with the backup */
102
String backupArn();
103
Builder backupArn(String backupArn);
104
}
105
106
class DescribeBackupResponse {
107
/** Contains the description of the backup created for the table */
108
BackupDescription backupDescription();
109
}
110
111
class BackupDescription {
112
/** Contains the details of the backup created for the table */
113
BackupDetails backupDetails();
114
115
/** Contains the details of the table when the backup was created */
116
SourceTableDetails sourceTableDetails();
117
118
/** Contains the details of the features enabled on the table when the backup was created */
119
SourceTableFeatureDetails sourceTableFeatureDetails();
120
}
121
122
class SourceTableDetails {
123
/** The name of the table for which the backup was created */
124
String tableName();
125
126
/** Unique identifier for the table for which the backup was created */
127
String tableId();
128
129
/** ARN of the table for which backup was created */
130
String tableArn();
131
132
/** Size of the table in bytes */
133
Long tableSizeBytes();
134
135
/** Schema of the table */
136
List<KeySchemaElement> keySchema();
137
138
/** Time when the source table was created */
139
Instant tableCreationDateTime();
140
141
/** Read IOPs and Write IOPS on the table when the backup was created */
142
ProvisionedThroughput provisionedThroughput();
143
144
/** Number of items in the table when the backup was created */
145
Long itemCount();
146
147
/** Controls how you are charged for read and write throughput */
148
BillingMode billingMode();
149
}
150
```
151
152
**Usage Example:**
153
154
```java
155
// Get detailed backup information
156
DescribeBackupResponse response = client.describeBackup(DescribeBackupRequest.builder()
157
.backupArn("arn:aws:dynamodb:us-east-1:123456789012:table/Orders/backup/01234567890123-abcdefab")
158
.build());
159
160
BackupDescription backup = response.backupDescription();
161
BackupDetails details = backup.backupDetails();
162
SourceTableDetails sourceTable = backup.sourceTableDetails();
163
164
System.out.println("Backup: " + details.backupName());
165
System.out.println("Status: " + details.backupStatus());
166
System.out.println("Size: " + details.backupSizeBytes() + " bytes");
167
System.out.println("Source table: " + sourceTable.tableName());
168
System.out.println("Source table size: " + sourceTable.tableSizeBytes() + " bytes");
169
System.out.println("Source item count: " + sourceTable.itemCount());
170
```
171
172
### List Backups
173
174
Lists all backups associated with the account, optionally filtered by table name or time range.
175
176
```java { .api }
177
/**
178
* Lists existing backups
179
* @param request - The request containing filter criteria
180
* @return Response containing list of backups
181
*/
182
ListBackupsResponse listBackups(ListBackupsRequest request);
183
184
class ListBackupsRequest {
185
static Builder builder();
186
187
/** The backups from the table specified by TableName are listed */
188
String tableName();
189
Builder tableName(String tableName);
190
191
/** Maximum number of backups to return at once */
192
Integer limit();
193
Builder limit(Integer limit);
194
195
/** Only backups created after this time are listed */
196
Instant timeRangeUpperBound();
197
Builder timeRangeUpperBound(Instant timeRangeUpperBound);
198
199
/** Only backups created before this time are listed */
200
Instant timeRangeLowerBound();
201
Builder timeRangeLowerBound(Instant timeRangeLowerBound);
202
203
/** LastEvaluatedBackupArn is the Amazon Resource Name (ARN) of the backup last evaluated */
204
String exclusiveStartBackupArn();
205
Builder exclusiveStartBackupArn(String exclusiveStartBackupArn);
206
207
/** The backups from the table specified by BackupType are listed */
208
BackupTypeFilter backupType();
209
Builder backupType(BackupTypeFilter backupType);
210
}
211
212
class ListBackupsResponse {
213
/** List of details about the backups stored in the account */
214
List<BackupSummary> backupSummaries();
215
216
/** The ARN of the backup last evaluated when the current page of results was returned */
217
String lastEvaluatedBackupArn();
218
}
219
220
class BackupSummary {
221
/** Name of the table */
222
String tableName();
223
224
/** Unique identifier for the table */
225
String tableId();
226
227
/** ARN associated with the table */
228
String tableArn();
229
230
/** ARN associated with the backup */
231
String backupArn();
232
233
/** Name of the specified backup */
234
String backupName();
235
236
/** Time at which the backup was created */
237
Instant backupCreationDateTime();
238
239
/** Time at which the automatic on-demand backup created by DynamoDB will expire */
240
Instant backupExpiryDateTime();
241
242
/** Backup can be in one of the following states: CREATING, DELETED, AVAILABLE */
243
BackupStatus backupStatus();
244
245
/** BackupType: USER for user-initiated backup. SYSTEM for system-initiated backup */
246
BackupType backupType();
247
248
/** Size of the backup in bytes */
249
Long backupSizeBytes();
250
}
251
```
252
253
**Usage Example:**
254
255
```java
256
import java.time.Instant;
257
import java.time.temporal.ChronoUnit;
258
259
// List all backups for a specific table created in the last 30 days
260
Instant thirtyDaysAgo = Instant.now().minus(30, ChronoUnit.DAYS);
261
262
ListBackupsResponse response = client.listBackups(ListBackupsRequest.builder()
263
.tableName("Orders")
264
.timeRangeLowerBound(thirtyDaysAgo)
265
.backupType(BackupTypeFilter.ALL)
266
.limit(50)
267
.build());
268
269
System.out.println("Found " + response.backupSummaries().size() + " backups:");
270
271
for (BackupSummary backup : response.backupSummaries()) {
272
System.out.println(" " + backup.backupName() +
273
" (" + backup.backupStatus() +
274
", " + backup.backupSizeBytes() + " bytes" +
275
", created: " + backup.backupCreationDateTime() + ")");
276
}
277
278
// Handle pagination if more backups exist
279
if (response.lastEvaluatedBackupArn() != null) {
280
// Use lastEvaluatedBackupArn as exclusiveStartBackupArn for next request
281
String nextStartArn = response.lastEvaluatedBackupArn();
282
}
283
```
284
285
### Delete Backup
286
287
Deletes an existing on-demand backup of a table.
288
289
```java { .api }
290
/**
291
* Deletes an existing backup of a table
292
* @param request - The request containing backup ARN to delete
293
* @return Response containing backup description
294
*/
295
DeleteBackupResponse deleteBackup(DeleteBackupRequest request);
296
297
class DeleteBackupRequest {
298
static Builder builder();
299
300
/** The ARN associated with the backup */
301
String backupArn();
302
Builder backupArn(String backupArn);
303
}
304
305
class DeleteBackupResponse {
306
/** Contains the description of the backup created for the table */
307
BackupDescription backupDescription();
308
}
309
```
310
311
**Usage Example:**
312
313
```java
314
// Delete a specific backup
315
try {
316
DeleteBackupResponse response = client.deleteBackup(DeleteBackupRequest.builder()
317
.backupArn("arn:aws:dynamodb:us-east-1:123456789012:table/Orders/backup/01234567890123-abcdefab")
318
.build());
319
320
BackupDetails deletedBackup = response.backupDescription().backupDetails();
321
System.out.println("Backup deleted: " + deletedBackup.backupName());
322
323
} catch (BackupNotFoundException e) {
324
System.err.println("Backup not found: " + e.getMessage());
325
} catch (BackupInUseException e) {
326
System.err.println("Backup is currently in use: " + e.getMessage());
327
}
328
```
329
330
### Restore Table from Backup
331
332
Creates a new table by restoring from an existing backup.
333
334
```java { .api }
335
/**
336
* Creates a new table from an existing backup
337
* @param request - The request containing backup ARN and target table configuration
338
* @return Response containing table description
339
*/
340
RestoreTableFromBackupResponse restoreTableFromBackup(RestoreTableFromBackupRequest request);
341
342
class RestoreTableFromBackupRequest {
343
static Builder builder();
344
345
/** The name of the new table to which the backup must be restored */
346
String targetTableName();
347
Builder targetTableName(String targetTableName);
348
349
/** The Amazon Resource Name (ARN) associated with the backup */
350
String backupArn();
351
Builder backupArn(String backupArn);
352
353
/** The billing mode of the restored table */
354
BillingMode billingModeOverride();
355
Builder billingModeOverride(BillingMode billingModeOverride);
356
357
/** List of global secondary indexes for the restored table */
358
List<GlobalSecondaryIndex> globalSecondaryIndexOverride();
359
Builder globalSecondaryIndexOverride(Collection<GlobalSecondaryIndex> globalSecondaryIndexOverride);
360
361
/** List of local secondary indexes for the restored table */
362
List<LocalSecondaryIndex> localSecondaryIndexOverride();
363
Builder localSecondaryIndexOverride(Collection<LocalSecondaryIndex> localSecondaryIndexOverride);
364
365
/** Provisioned throughput settings for the restored table */
366
ProvisionedThroughput provisionedThroughputOverride();
367
Builder provisionedThroughputOverride(ProvisionedThroughput provisionedThroughputOverride);
368
369
/** The new server-side encryption settings for the restored table */
370
SSESpecification sseSpecificationOverride();
371
Builder sseSpecificationOverride(SSESpecification sseSpecificationOverride);
372
}
373
374
class RestoreTableFromBackupResponse {
375
/** Represents the properties of the table being restored */
376
TableDescription tableDescription();
377
}
378
```
379
380
**Usage Example:**
381
382
```java
383
// Restore table from backup with modifications
384
RestoreTableFromBackupResponse response = client.restoreTableFromBackup(
385
RestoreTableFromBackupRequest.builder()
386
.targetTableName("Orders-Restored-2025-09-07")
387
.backupArn("arn:aws:dynamodb:us-east-1:123456789012:table/Orders/backup/01234567890123-abcdefab")
388
.billingModeOverride(BillingMode.PAY_PER_REQUEST) // Change to on-demand
389
.sseSpecificationOverride(SSESpecification.builder()
390
.enabled(true)
391
.sseType(SSEType.KMS)
392
.build())
393
.build()
394
);
395
396
TableDescription restoredTable = response.tableDescription();
397
System.out.println("Table restore initiated: " + restoredTable.tableName());
398
System.out.println("Status: " + restoredTable.tableStatus());
399
System.out.println("ARN: " + restoredTable.tableArn());
400
```
401
402
### Point-in-Time Recovery
403
404
Restore a table to any point in time within the retention period (up to 35 days).
405
406
```java { .api }
407
/**
408
* Restores the specified table to the specified point in time within EarliestRestorableDateTime and LatestRestorableDateTime
409
* @param request - The request containing source table and target point in time
410
* @return Response containing table description
411
*/
412
RestoreTableToPointInTimeResponse restoreTableToPointInTime(RestoreTableToPointInTimeRequest request);
413
414
class RestoreTableToPointInTimeRequest {
415
static Builder builder();
416
417
/** The DynamoDB table that will be restored. This value is an Amazon Resource Name (ARN) */
418
String sourceTableArn();
419
Builder sourceTableArn(String sourceTableArn);
420
421
/** Name of the source table that is being restored */
422
String sourceTableName();
423
Builder sourceTableName(String sourceTableName);
424
425
/** The name of the new table to which it must be restored to */
426
String targetTableName();
427
Builder targetTableName(String targetTableName);
428
429
/** Restore the table to the latest possible time */
430
Boolean useLatestRestorableTime();
431
Builder useLatestRestorableTime(Boolean useLatestRestorableTime);
432
433
/** Time in the past to restore the table to */
434
Instant restoreDateTime();
435
Builder restoreDateTime(Instant restoreDateTime);
436
437
/** The billing mode of the restored table */
438
BillingMode billingModeOverride();
439
Builder billingModeOverride(BillingMode billingModeOverride);
440
441
/** List of global secondary indexes for the restored table */
442
List<GlobalSecondaryIndex> globalSecondaryIndexOverride();
443
Builder globalSecondaryIndexOverride(Collection<GlobalSecondaryIndex> globalSecondaryIndexOverride);
444
445
/** List of local secondary indexes for the restored table */
446
List<LocalSecondaryIndex> localSecondaryIndexOverride();
447
Builder localSecondaryIndexOverride(Collection<LocalSecondaryIndex> localSecondaryIndexOverride);
448
449
/** Provisioned throughput settings for the restored table */
450
ProvisionedThroughput provisionedThroughputOverride();
451
Builder provisionedThroughputOverride(ProvisionedThroughput provisionedThroughputOverride);
452
453
/** The new server-side encryption settings for the restored table */
454
SSESpecification sseSpecificationOverride();
455
Builder sseSpecificationOverride(SSESpecification sseSpecificationOverride);
456
}
457
458
class RestoreTableToPointInTimeResponse {
459
/** Represents the properties of the table being restored */
460
TableDescription tableDescription();
461
}
462
```
463
464
**Usage Example:**
465
466
```java
467
import java.time.Instant;
468
import java.time.temporal.ChronoUnit;
469
470
// Restore table to a specific point in time (2 hours ago)
471
Instant restoreTime = Instant.now().minus(2, ChronoUnit.HOURS);
472
473
RestoreTableToPointInTimeResponse response = client.restoreTableToPointInTime(
474
RestoreTableToPointInTimeRequest.builder()
475
.sourceTableName("Orders")
476
.targetTableName("Orders-PITR-Recovery-2025-09-07")
477
.restoreDateTime(restoreTime)
478
.billingModeOverride(BillingMode.PAY_PER_REQUEST)
479
.build()
480
);
481
482
TableDescription restoredTable = response.tableDescription();
483
System.out.println("Point-in-time restore iniciado: " + restoredTable.tableName());
484
System.out.println("Status: " + restoredTable.tableStatus());
485
486
// Restore to latest restorable time
487
RestoreTableToPointInTimeResponse latestResponse = client.restoreTableToPointInTime(
488
RestoreTableToPointInTimeRequest.builder()
489
.sourceTableName("Orders")
490
.targetTableName("Orders-Latest-Recovery")
491
.useLatestRestorableTime(true) // Restore to most recent point
492
.build()
493
);
494
```
495
496
## Continuous Backups Configuration
497
498
### Describe Continuous Backups
499
500
Check the current continuous backup and point-in-time recovery settings.
501
502
```java { .api }
503
/**
504
* Checks the status of continuous backups and point in time recovery on the specified table
505
* @param request - The request containing table name
506
* @return Response containing backup configuration
507
*/
508
DescribeContinuousBackupsResponse describeContinuousBackups(DescribeContinuousBackupsRequest request);
509
510
class DescribeContinuousBackupsRequest {
511
static Builder builder();
512
513
/** Name of the table for which the customer wants to check the continuous backups status */
514
String tableName();
515
Builder tableName(String tableName);
516
}
517
518
class DescribeContinuousBackupsResponse {
519
/** Represents the continuous backups and point in time recovery settings on the table */
520
ContinuousBackupsDescription continuousBackupsDescription();
521
}
522
523
class ContinuousBackupsDescription {
524
/** The current status of continuous backups */
525
ContinuousBackupsStatus continuousBackupsStatus();
526
527
/** The description of the point in time recovery settings applied to the table */
528
PointInTimeRecoveryDescription pointInTimeRecoveryDescription();
529
}
530
531
class PointInTimeRecoveryDescription {
532
/** The current state of point in time recovery */
533
PointInTimeRecoveryStatus pointInTimeRecoveryStatus();
534
535
/** Specifies the earliest point in time you can restore your table to */
536
Instant earliestRestorableDateTime();
537
538
/** LatestRestorableDateTime is typically 5 minutes before the current time */
539
Instant latestRestorableDateTime();
540
}
541
```
542
543
### Update Continuous Backups
544
545
Enable or disable continuous backups and point-in-time recovery.
546
547
```java { .api }
548
/**
549
* Updates the continuous backups and point in time recovery configuration for the specified table
550
* @param request - The request containing backup configuration
551
* @return Response containing updated backup description
552
*/
553
UpdateContinuousBackupsResponse updateContinuousBackups(UpdateContinuousBackupsRequest request);
554
555
class UpdateContinuousBackupsRequest {
556
static Builder builder();
557
558
/** The name of the table */
559
String tableName();
560
Builder tableName(String tableName);
561
562
/** Represents the settings used to enable point in time recovery */
563
PointInTimeRecoverySpecification pointInTimeRecoverySpecification();
564
Builder pointInTimeRecoverySpecification(PointInTimeRecoverySpecification pointInTimeRecoverySpecification);
565
}
566
567
class PointInTimeRecoverySpecification {
568
static Builder builder();
569
570
/** Indicates whether point in time recovery is enabled (true) or disabled (false) on the table */
571
Boolean pointInTimeRecoveryEnabled();
572
Builder pointInTimeRecoveryEnabled(Boolean pointInTimeRecoveryEnabled);
573
}
574
575
class UpdateContinuousBackupsResponse {
576
/** Represents the continuous backups and point in time recovery settings on the table */
577
ContinuousBackupsDescription continuousBackupsDescription();
578
}
579
```
580
581
**Usage Example:**
582
583
```java
584
// Check current backup status
585
DescribeContinuousBackupsResponse status = client.describeContinuousBackups(
586
DescribeContinuousBackupsRequest.builder()
587
.tableName("Orders")
588
.build()
589
);
590
591
ContinuousBackupsDescription backups = status.continuousBackupsDescription();
592
PointInTimeRecoveryDescription pitr = backups.pointInTimeRecoveryDescription();
593
594
System.out.println("Continuous backups: " + backups.continuousBackupsStatus());
595
System.out.println("Point-in-time recovery: " + pitr.pointInTimeRecoveryStatus());
596
System.out.println("Earliest restorable: " + pitr.earliestRestorableDateTime());
597
System.out.println("Latest restorable: " + pitr.latestRestorableDateTime());
598
599
// Enable point-in-time recovery
600
UpdateContinuousBackupsResponse updateResponse = client.updateContinuousBackups(
601
UpdateContinuousBackupsRequest.builder()
602
.tableName("Orders")
603
.pointInTimeRecoverySpecification(
604
PointInTimeRecoverySpecification.builder()
605
.pointInTimeRecoveryEnabled(true)
606
.build()
607
)
608
.build()
609
);
610
611
System.out.println("Point-in-time recovery enabled");
612
```
613
614
## Backup and Restore Best Practices
615
616
### Backup Strategy
617
618
1. **Regular On-Demand Backups**: Create scheduled backups for critical data
619
2. **Point-in-Time Recovery**: Enable PITR for tables requiring fine-grained recovery
620
3. **Cross-Region Backups**: Consider copying backups to other regions for disaster recovery
621
4. **Backup Retention**: Implement a retention policy to manage storage costs
622
623
```java
624
// Example backup automation
625
public void createScheduledBackup(String tableName) {
626
String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd-HH-mm"));
627
String backupName = tableName + "-scheduled-" + timestamp;
628
629
try {
630
CreateBackupResponse response = client.createBackup(CreateBackupRequest.builder()
631
.tableName(tableName)
632
.backupName(backupName)
633
.build());
634
635
System.out.println("Scheduled backup created: " + response.backupDetails().backupName());
636
637
// Optional: Clean up old backups
638
cleanupOldBackups(tableName, 30); // Keep last 30 days
639
640
} catch (Exception e) {
641
System.err.println("Failed to create backup: " + e.getMessage());
642
}
643
}
644
```
645
646
### Restore Considerations
647
648
1. **Table Naming**: Use descriptive names for restored tables
649
2. **Configuration Updates**: Adjust billing mode, throughput, and encryption as needed
650
3. **Index Management**: Consider which indexes are needed for the restored table
651
4. **Data Validation**: Verify data integrity after restore
652
653
```java
654
// Example restore with validation
655
public void restoreWithValidation(String backupArn, String targetTableName) {
656
// Restore table
657
RestoreTableFromBackupResponse response = client.restoreTableFromBackup(
658
RestoreTableFromBackupRequest.builder()
659
.backupArn(backupArn)
660
.targetTableName(targetTableName)
661
.billingModeOverride(BillingMode.PAY_PER_REQUEST)
662
.build()
663
);
664
665
// Wait for table to become active
666
waitForTableActive(targetTableName);
667
668
// Validate restored data
669
validateRestoredTable(targetTableName);
670
}
671
```
672
673
### Cost Optimization
674
675
1. **Backup Lifecycle**: Delete unnecessary backups regularly
676
2. **PITR Management**: Enable PITR only for tables that need it
677
3. **Backup Frequency**: Balance recovery needs with storage costs
678
679
```java
680
// Clean up old backups
681
public void cleanupOldBackups(String tableName, int retentionDays) {
682
Instant cutoffDate = Instant.now().minus(retentionDays, ChronoUnit.DAYS);
683
684
ListBackupsResponse response = client.listBackups(ListBackupsRequest.builder()
685
.tableName(tableName)
686
.timeRangeUpperBound(cutoffDate)
687
.backupType(BackupTypeFilter.USER)
688
.build());
689
690
for (BackupSummary backup : response.backupSummaries()) {
691
if (backup.backupStatus() == BackupStatus.AVAILABLE) {
692
try {
693
client.deleteBackup(DeleteBackupRequest.builder()
694
.backupArn(backup.backupArn())
695
.build());
696
697
System.out.println("Deleted old backup: " + backup.backupName());
698
699
} catch (Exception e) {
700
System.err.println("Failed to delete backup " + backup.backupName() + ": " + e.getMessage());
701
}
702
}
703
}
704
}
705
```
706
707
## Additional Type Definitions
708
709
### Backup Status and Type Enums
710
711
```java { .api }
712
enum BackupStatus {
713
CREATING("CREATING"),
714
DELETED("DELETED"),
715
AVAILABLE("AVAILABLE");
716
}
717
718
enum BackupType {
719
USER("USER"),
720
SYSTEM("SYSTEM"),
721
AWS_BACKUP("AWS_BACKUP");
722
}
723
724
enum BackupTypeFilter {
725
USER("USER"),
726
SYSTEM("SYSTEM"),
727
AWS_BACKUP("AWS_BACKUP"),
728
ALL("ALL");
729
}
730
731
enum ContinuousBackupsStatus {
732
ENABLED("ENABLED"),
733
DISABLED("DISABLED");
734
}
735
736
enum PointInTimeRecoveryStatus {
737
ENABLED("ENABLED"),
738
DISABLED("DISABLED");
739
}
740
```