@aws-sdk/client-backup 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2211 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AdvancedBackupSetting {
+    
+    ResourceType?: string;
+    
+    BackupOptions?: {
+        [key: string]: string;
+    };
+}
+export declare namespace AdvancedBackupSetting {
+    
+    const filterSensitiveLog: (obj: AdvancedBackupSetting) => any;
+}
+
+export interface AlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "AlreadyExistsException";
+    $fault: "client";
+    Code?: string;
+    Message?: string;
+    
+    CreatorRequestId?: string;
+    
+    Arn?: string;
+    
+    Type?: string;
+    
+    Context?: string;
+}
+
+export interface RecoveryPointCreator {
+    
+    BackupPlanId?: string;
+    
+    BackupPlanArn?: string;
+    
+    BackupPlanVersion?: string;
+    
+    BackupRuleId?: string;
+}
+export declare namespace RecoveryPointCreator {
+    
+    const filterSensitiveLog: (obj: RecoveryPointCreator) => any;
+}
+export declare enum BackupJobState {
+    ABORTED = "ABORTED",
+    ABORTING = "ABORTING",
+    COMPLETED = "COMPLETED",
+    CREATED = "CREATED",
+    EXPIRED = "EXPIRED",
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    RUNNING = "RUNNING"
+}
+
+export interface BackupJob {
+    
+    AccountId?: string;
+    
+    BackupJobId?: string;
+    
+    BackupVaultName?: string;
+    
+    BackupVaultArn?: string;
+    
+    RecoveryPointArn?: string;
+    
+    ResourceArn?: string;
+    
+    CreationDate?: Date;
+    
+    CompletionDate?: Date;
+    
+    State?: BackupJobState | string;
+    
+    StatusMessage?: string;
+    
+    PercentDone?: string;
+    
+    BackupSizeInBytes?: number;
+    
+    IamRoleArn?: string;
+    
+    CreatedBy?: RecoveryPointCreator;
+    
+    ExpectedCompletionDate?: Date;
+    
+    StartBy?: Date;
+    
+    ResourceType?: string;
+    
+    BytesTransferred?: number;
+    
+    BackupOptions?: {
+        [key: string]: string;
+    };
+    
+    BackupType?: string;
+}
+export declare namespace BackupJob {
+    
+    const filterSensitiveLog: (obj: BackupJob) => any;
+}
+
+export interface Lifecycle {
+    
+    MoveToColdStorageAfterDays?: number;
+    
+    DeleteAfterDays?: number;
+}
+export declare namespace Lifecycle {
+    
+    const filterSensitiveLog: (obj: Lifecycle) => any;
+}
+
+export interface CopyAction {
+    
+    Lifecycle?: Lifecycle;
+    
+    DestinationBackupVaultArn: string | undefined;
+}
+export declare namespace CopyAction {
+    
+    const filterSensitiveLog: (obj: CopyAction) => any;
+}
+
+export interface BackupRule {
+    
+    RuleName: string | undefined;
+    
+    TargetBackupVaultName: string | undefined;
+    
+    ScheduleExpression?: string;
+    
+    StartWindowMinutes?: number;
+    
+    CompletionWindowMinutes?: number;
+    
+    Lifecycle?: Lifecycle;
+    
+    RecoveryPointTags?: {
+        [key: string]: string;
+    };
+    
+    RuleId?: string;
+    
+    CopyActions?: CopyAction[];
+    
+    EnableContinuousBackup?: boolean;
+}
+export declare namespace BackupRule {
+    
+    const filterSensitiveLog: (obj: BackupRule) => any;
+}
+
+export interface BackupPlan {
+    
+    BackupPlanName: string | undefined;
+    
+    Rules: BackupRule[] | undefined;
+    
+    AdvancedBackupSettings?: AdvancedBackupSetting[];
+}
+export declare namespace BackupPlan {
+    
+    const filterSensitiveLog: (obj: BackupPlan) => any;
+}
+
+export interface BackupRuleInput {
+    
+    RuleName: string | undefined;
+    
+    TargetBackupVaultName: string | undefined;
+    
+    ScheduleExpression?: string;
+    
+    StartWindowMinutes?: number;
+    
+    CompletionWindowMinutes?: number;
+    
+    Lifecycle?: Lifecycle;
+    
+    RecoveryPointTags?: {
+        [key: string]: string;
+    };
+    
+    CopyActions?: CopyAction[];
+    
+    EnableContinuousBackup?: boolean;
+}
+export declare namespace BackupRuleInput {
+    
+    const filterSensitiveLog: (obj: BackupRuleInput) => any;
+}
+
+export interface BackupPlanInput {
+    
+    BackupPlanName: string | undefined;
+    
+    Rules: BackupRuleInput[] | undefined;
+    
+    AdvancedBackupSettings?: AdvancedBackupSetting[];
+}
+export declare namespace BackupPlanInput {
+    
+    const filterSensitiveLog: (obj: BackupPlanInput) => any;
+}
+
+export interface BackupPlansListMember {
+    
+    BackupPlanArn?: string;
+    
+    BackupPlanId?: string;
+    
+    CreationDate?: Date;
+    
+    DeletionDate?: Date;
+    
+    VersionId?: string;
+    
+    BackupPlanName?: string;
+    
+    CreatorRequestId?: string;
+    
+    LastExecutionDate?: Date;
+    
+    AdvancedBackupSettings?: AdvancedBackupSetting[];
+}
+export declare namespace BackupPlansListMember {
+    
+    const filterSensitiveLog: (obj: BackupPlansListMember) => any;
+}
+
+export interface BackupPlanTemplatesListMember {
+    
+    BackupPlanTemplateId?: string;
+    
+    BackupPlanTemplateName?: string;
+}
+export declare namespace BackupPlanTemplatesListMember {
+    
+    const filterSensitiveLog: (obj: BackupPlanTemplatesListMember) => any;
+}
+
+export interface ConditionParameter {
+    
+    ConditionKey?: string;
+    
+    ConditionValue?: string;
+}
+export declare namespace ConditionParameter {
+    
+    const filterSensitiveLog: (obj: ConditionParameter) => any;
+}
+
+export interface Conditions {
+    
+    StringEquals?: ConditionParameter[];
+    
+    StringNotEquals?: ConditionParameter[];
+    
+    StringLike?: ConditionParameter[];
+    
+    StringNotLike?: ConditionParameter[];
+}
+export declare namespace Conditions {
+    
+    const filterSensitiveLog: (obj: Conditions) => any;
+}
+export declare enum ConditionType {
+    STRINGEQUALS = "STRINGEQUALS"
+}
+
+export interface Condition {
+    
+    ConditionType: ConditionType | string | undefined;
+    
+    ConditionKey: string | undefined;
+    
+    ConditionValue: string | undefined;
+}
+export declare namespace Condition {
+    
+    const filterSensitiveLog: (obj: Condition) => any;
+}
+
+export interface BackupSelection {
+    
+    SelectionName: string | undefined;
+    
+    IamRoleArn: string | undefined;
+    
+    Resources?: string[];
+    
+    ListOfTags?: Condition[];
+    
+    NotResources?: string[];
+    
+    Conditions?: Conditions;
+}
+export declare namespace BackupSelection {
+    
+    const filterSensitiveLog: (obj: BackupSelection) => any;
+}
+
+export interface BackupSelectionsListMember {
+    
+    SelectionId?: string;
+    
+    SelectionName?: string;
+    
+    BackupPlanId?: string;
+    
+    CreationDate?: Date;
+    
+    CreatorRequestId?: string;
+    
+    IamRoleArn?: string;
+}
+export declare namespace BackupSelectionsListMember {
+    
+    const filterSensitiveLog: (obj: BackupSelectionsListMember) => any;
+}
+export declare enum BackupVaultEvent {
+    BACKUP_JOB_COMPLETED = "BACKUP_JOB_COMPLETED",
+    BACKUP_JOB_EXPIRED = "BACKUP_JOB_EXPIRED",
+    BACKUP_JOB_FAILED = "BACKUP_JOB_FAILED",
+    BACKUP_JOB_STARTED = "BACKUP_JOB_STARTED",
+    BACKUP_JOB_SUCCESSFUL = "BACKUP_JOB_SUCCESSFUL",
+    BACKUP_PLAN_CREATED = "BACKUP_PLAN_CREATED",
+    BACKUP_PLAN_MODIFIED = "BACKUP_PLAN_MODIFIED",
+    COPY_JOB_FAILED = "COPY_JOB_FAILED",
+    COPY_JOB_STARTED = "COPY_JOB_STARTED",
+    COPY_JOB_SUCCESSFUL = "COPY_JOB_SUCCESSFUL",
+    RECOVERY_POINT_MODIFIED = "RECOVERY_POINT_MODIFIED",
+    RESTORE_JOB_COMPLETED = "RESTORE_JOB_COMPLETED",
+    RESTORE_JOB_FAILED = "RESTORE_JOB_FAILED",
+    RESTORE_JOB_STARTED = "RESTORE_JOB_STARTED",
+    RESTORE_JOB_SUCCESSFUL = "RESTORE_JOB_SUCCESSFUL"
+}
+
+export interface BackupVaultListMember {
+    
+    BackupVaultName?: string;
+    
+    BackupVaultArn?: string;
+    
+    CreationDate?: Date;
+    
+    EncryptionKeyArn?: string;
+    
+    CreatorRequestId?: string;
+    
+    NumberOfRecoveryPoints?: number;
+    
+    Locked?: boolean;
+    
+    MinRetentionDays?: number;
+    
+    MaxRetentionDays?: number;
+    
+    LockDate?: Date;
+}
+export declare namespace BackupVaultListMember {
+    
+    const filterSensitiveLog: (obj: BackupVaultListMember) => any;
+}
+
+export interface CalculatedLifecycle {
+    
+    MoveToColdStorageAt?: Date;
+    
+    DeleteAt?: Date;
+}
+export declare namespace CalculatedLifecycle {
+    
+    const filterSensitiveLog: (obj: CalculatedLifecycle) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    Code?: string;
+    Message?: string;
+    
+    Type?: string;
+    
+    Context?: string;
+}
+
+export interface ControlInputParameter {
+    
+    ParameterName?: string;
+    
+    ParameterValue?: string;
+}
+export declare namespace ControlInputParameter {
+    
+    const filterSensitiveLog: (obj: ControlInputParameter) => any;
+}
+
+export interface ControlScope {
+    
+    ComplianceResourceIds?: string[];
+    
+    ComplianceResourceTypes?: string[];
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ControlScope {
+    
+    const filterSensitiveLog: (obj: ControlScope) => any;
+}
+export declare enum CopyJobState {
+    COMPLETED = "COMPLETED",
+    CREATED = "CREATED",
+    FAILED = "FAILED",
+    RUNNING = "RUNNING"
+}
+
+export interface CopyJob {
+    
+    AccountId?: string;
+    
+    CopyJobId?: string;
+    
+    SourceBackupVaultArn?: string;
+    
+    SourceRecoveryPointArn?: string;
+    
+    DestinationBackupVaultArn?: string;
+    
+    DestinationRecoveryPointArn?: string;
+    
+    ResourceArn?: string;
+    
+    CreationDate?: Date;
+    
+    CompletionDate?: Date;
+    
+    State?: CopyJobState | string;
+    
+    StatusMessage?: string;
+    
+    BackupSizeInBytes?: number;
+    
+    IamRoleArn?: string;
+    
+    CreatedBy?: RecoveryPointCreator;
+    
+    ResourceType?: string;
+}
+export declare namespace CopyJob {
+    
+    const filterSensitiveLog: (obj: CopyJob) => any;
+}
+export interface CreateBackupPlanInput {
+    
+    BackupPlan: BackupPlanInput | undefined;
+    
+    BackupPlanTags?: {
+        [key: string]: string;
+    };
+    
+    CreatorRequestId?: string;
+}
+export declare namespace CreateBackupPlanInput {
+    
+    const filterSensitiveLog: (obj: CreateBackupPlanInput) => any;
+}
+export interface CreateBackupPlanOutput {
+    
+    BackupPlanId?: string;
+    
+    BackupPlanArn?: string;
+    
+    CreationDate?: Date;
+    
+    VersionId?: string;
+    
+    AdvancedBackupSettings?: AdvancedBackupSetting[];
+}
+export declare namespace CreateBackupPlanOutput {
+    
+    const filterSensitiveLog: (obj: CreateBackupPlanOutput) => any;
+}
+
+export interface InvalidParameterValueException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterValueException";
+    $fault: "client";
+    Code?: string;
+    Message?: string;
+    
+    Type?: string;
+    
+    Context?: string;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    Code?: string;
+    Message?: string;
+    
+    Type?: string;
+    
+    Context?: string;
+}
+
+export interface MissingParameterValueException extends __SmithyException, $MetadataBearer {
+    name: "MissingParameterValueException";
+    $fault: "client";
+    Code?: string;
+    Message?: string;
+    
+    Type?: string;
+    
+    Context?: string;
+}
+
+export interface ServiceUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "ServiceUnavailableException";
+    $fault: "server";
+    Code?: string;
+    Message?: string;
+    
+    Type?: string;
+    
+    Context?: string;
+}
+export interface CreateBackupSelectionInput {
+    
+    BackupPlanId: string | undefined;
+    
+    BackupSelection: BackupSelection | undefined;
+    
+    CreatorRequestId?: string;
+}
+export declare namespace CreateBackupSelectionInput {
+    
+    const filterSensitiveLog: (obj: CreateBackupSelectionInput) => any;
+}
+export interface CreateBackupSelectionOutput {
+    
+    SelectionId?: string;
+    
+    BackupPlanId?: string;
+    
+    CreationDate?: Date;
+}
+export declare namespace CreateBackupSelectionOutput {
+    
+    const filterSensitiveLog: (obj: CreateBackupSelectionOutput) => any;
+}
+export interface CreateBackupVaultInput {
+    
+    BackupVaultName: string | undefined;
+    
+    BackupVaultTags?: {
+        [key: string]: string;
+    };
+    
+    EncryptionKeyArn?: string;
+    
+    CreatorRequestId?: string;
+}
+export declare namespace CreateBackupVaultInput {
+    
+    const filterSensitiveLog: (obj: CreateBackupVaultInput) => any;
+}
+export interface CreateBackupVaultOutput {
+    
+    BackupVaultName?: string;
+    
+    BackupVaultArn?: string;
+    
+    CreationDate?: Date;
+}
+export declare namespace CreateBackupVaultOutput {
+    
+    const filterSensitiveLog: (obj: CreateBackupVaultOutput) => any;
+}
+
+export interface FrameworkControl {
+    
+    ControlName: string | undefined;
+    
+    ControlInputParameters?: ControlInputParameter[];
+    
+    ControlScope?: ControlScope;
+}
+export declare namespace FrameworkControl {
+    
+    const filterSensitiveLog: (obj: FrameworkControl) => any;
+}
+export interface CreateFrameworkInput {
+    
+    FrameworkName: string | undefined;
+    
+    FrameworkDescription?: string;
+    
+    FrameworkControls: FrameworkControl[] | undefined;
+    
+    IdempotencyToken?: string;
+    
+    FrameworkTags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateFrameworkInput {
+    
+    const filterSensitiveLog: (obj: CreateFrameworkInput) => any;
+}
+export interface CreateFrameworkOutput {
+    
+    FrameworkName?: string;
+    
+    FrameworkArn?: string;
+}
+export declare namespace CreateFrameworkOutput {
+    
+    const filterSensitiveLog: (obj: CreateFrameworkOutput) => any;
+}
+
+export interface ReportDeliveryChannel {
+    
+    S3BucketName: string | undefined;
+    
+    S3KeyPrefix?: string;
+    
+    Formats?: string[];
+}
+export declare namespace ReportDeliveryChannel {
+    
+    const filterSensitiveLog: (obj: ReportDeliveryChannel) => any;
+}
+
+export interface ReportSetting {
+    
+    ReportTemplate: string | undefined;
+    
+    FrameworkArns?: string[];
+    
+    NumberOfFrameworks?: number;
+}
+export declare namespace ReportSetting {
+    
+    const filterSensitiveLog: (obj: ReportSetting) => any;
+}
+export interface CreateReportPlanInput {
+    
+    ReportPlanName: string | undefined;
+    
+    ReportPlanDescription?: string;
+    
+    ReportDeliveryChannel: ReportDeliveryChannel | undefined;
+    
+    ReportSetting: ReportSetting | undefined;
+    
+    ReportPlanTags?: {
+        [key: string]: string;
+    };
+    
+    IdempotencyToken?: string;
+}
+export declare namespace CreateReportPlanInput {
+    
+    const filterSensitiveLog: (obj: CreateReportPlanInput) => any;
+}
+export interface CreateReportPlanOutput {
+    
+    ReportPlanName?: string;
+    
+    ReportPlanArn?: string;
+    
+    CreationTime?: Date;
+}
+export declare namespace CreateReportPlanOutput {
+    
+    const filterSensitiveLog: (obj: CreateReportPlanOutput) => any;
+}
+export interface DeleteBackupPlanInput {
+    
+    BackupPlanId: string | undefined;
+}
+export declare namespace DeleteBackupPlanInput {
+    
+    const filterSensitiveLog: (obj: DeleteBackupPlanInput) => any;
+}
+export interface DeleteBackupPlanOutput {
+    
+    BackupPlanId?: string;
+    
+    BackupPlanArn?: string;
+    
+    DeletionDate?: Date;
+    
+    VersionId?: string;
+}
+export declare namespace DeleteBackupPlanOutput {
+    
+    const filterSensitiveLog: (obj: DeleteBackupPlanOutput) => any;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    Code?: string;
+    Message?: string;
+    
+    Type?: string;
+    
+    Context?: string;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    Code?: string;
+    Message?: string;
+    
+    Type?: string;
+    
+    Context?: string;
+}
+export interface DeleteBackupSelectionInput {
+    
+    BackupPlanId: string | undefined;
+    
+    SelectionId: string | undefined;
+}
+export declare namespace DeleteBackupSelectionInput {
+    
+    const filterSensitiveLog: (obj: DeleteBackupSelectionInput) => any;
+}
+export interface DeleteBackupVaultInput {
+    
+    BackupVaultName: string | undefined;
+}
+export declare namespace DeleteBackupVaultInput {
+    
+    const filterSensitiveLog: (obj: DeleteBackupVaultInput) => any;
+}
+export interface DeleteBackupVaultAccessPolicyInput {
+    
+    BackupVaultName: string | undefined;
+}
+export declare namespace DeleteBackupVaultAccessPolicyInput {
+    
+    const filterSensitiveLog: (obj: DeleteBackupVaultAccessPolicyInput) => any;
+}
+export interface DeleteBackupVaultLockConfigurationInput {
+    
+    BackupVaultName: string | undefined;
+}
+export declare namespace DeleteBackupVaultLockConfigurationInput {
+    
+    const filterSensitiveLog: (obj: DeleteBackupVaultLockConfigurationInput) => any;
+}
+export interface DeleteBackupVaultNotificationsInput {
+    
+    BackupVaultName: string | undefined;
+}
+export declare namespace DeleteBackupVaultNotificationsInput {
+    
+    const filterSensitiveLog: (obj: DeleteBackupVaultNotificationsInput) => any;
+}
+export interface DeleteFrameworkInput {
+    
+    FrameworkName: string | undefined;
+}
+export declare namespace DeleteFrameworkInput {
+    
+    const filterSensitiveLog: (obj: DeleteFrameworkInput) => any;
+}
+export interface DeleteRecoveryPointInput {
+    
+    BackupVaultName: string | undefined;
+    
+    RecoveryPointArn: string | undefined;
+}
+export declare namespace DeleteRecoveryPointInput {
+    
+    const filterSensitiveLog: (obj: DeleteRecoveryPointInput) => any;
+}
+
+export interface InvalidResourceStateException extends __SmithyException, $MetadataBearer {
+    name: "InvalidResourceStateException";
+    $fault: "client";
+    Code?: string;
+    Message?: string;
+    
+    Type?: string;
+    
+    Context?: string;
+}
+export interface DeleteReportPlanInput {
+    
+    ReportPlanName: string | undefined;
+}
+export declare namespace DeleteReportPlanInput {
+    
+    const filterSensitiveLog: (obj: DeleteReportPlanInput) => any;
+}
+
+export interface DependencyFailureException extends __SmithyException, $MetadataBearer {
+    name: "DependencyFailureException";
+    $fault: "server";
+    Code?: string;
+    Message?: string;
+    
+    Type?: string;
+    
+    Context?: string;
+}
+export interface DescribeBackupJobInput {
+    
+    BackupJobId: string | undefined;
+}
+export declare namespace DescribeBackupJobInput {
+    
+    const filterSensitiveLog: (obj: DescribeBackupJobInput) => any;
+}
+export interface DescribeBackupJobOutput {
+    
+    AccountId?: string;
+    
+    BackupJobId?: string;
+    
+    BackupVaultName?: string;
+    
+    BackupVaultArn?: string;
+    
+    RecoveryPointArn?: string;
+    
+    ResourceArn?: string;
+    
+    CreationDate?: Date;
+    
+    CompletionDate?: Date;
+    
+    State?: BackupJobState | string;
+    
+    StatusMessage?: string;
+    
+    PercentDone?: string;
+    
+    BackupSizeInBytes?: number;
+    
+    IamRoleArn?: string;
+    
+    CreatedBy?: RecoveryPointCreator;
+    
+    ResourceType?: string;
+    
+    BytesTransferred?: number;
+    
+    ExpectedCompletionDate?: Date;
+    
+    StartBy?: Date;
+    
+    BackupOptions?: {
+        [key: string]: string;
+    };
+    
+    BackupType?: string;
+}
+export declare namespace DescribeBackupJobOutput {
+    
+    const filterSensitiveLog: (obj: DescribeBackupJobOutput) => any;
+}
+export interface DescribeBackupVaultInput {
+    
+    BackupVaultName: string | undefined;
+}
+export declare namespace DescribeBackupVaultInput {
+    
+    const filterSensitiveLog: (obj: DescribeBackupVaultInput) => any;
+}
+export interface DescribeBackupVaultOutput {
+    
+    BackupVaultName?: string;
+    
+    BackupVaultArn?: string;
+    
+    EncryptionKeyArn?: string;
+    
+    CreationDate?: Date;
+    
+    CreatorRequestId?: string;
+    
+    NumberOfRecoveryPoints?: number;
+    
+    Locked?: boolean;
+    
+    MinRetentionDays?: number;
+    
+    MaxRetentionDays?: number;
+    
+    LockDate?: Date;
+}
+export declare namespace DescribeBackupVaultOutput {
+    
+    const filterSensitiveLog: (obj: DescribeBackupVaultOutput) => any;
+}
+export interface DescribeCopyJobInput {
+    
+    CopyJobId: string | undefined;
+}
+export declare namespace DescribeCopyJobInput {
+    
+    const filterSensitiveLog: (obj: DescribeCopyJobInput) => any;
+}
+export interface DescribeCopyJobOutput {
+    
+    CopyJob?: CopyJob;
+}
+export declare namespace DescribeCopyJobOutput {
+    
+    const filterSensitiveLog: (obj: DescribeCopyJobOutput) => any;
+}
+export interface DescribeFrameworkInput {
+    
+    FrameworkName: string | undefined;
+}
+export declare namespace DescribeFrameworkInput {
+    
+    const filterSensitiveLog: (obj: DescribeFrameworkInput) => any;
+}
+export interface DescribeFrameworkOutput {
+    
+    FrameworkName?: string;
+    
+    FrameworkArn?: string;
+    
+    FrameworkDescription?: string;
+    
+    FrameworkControls?: FrameworkControl[];
+    
+    CreationTime?: Date;
+    
+    DeploymentStatus?: string;
+    
+    FrameworkStatus?: string;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace DescribeFrameworkOutput {
+    
+    const filterSensitiveLog: (obj: DescribeFrameworkOutput) => any;
+}
+export interface DescribeGlobalSettingsInput {
+}
+export declare namespace DescribeGlobalSettingsInput {
+    
+    const filterSensitiveLog: (obj: DescribeGlobalSettingsInput) => any;
+}
+export interface DescribeGlobalSettingsOutput {
+    
+    GlobalSettings?: {
+        [key: string]: string;
+    };
+    
+    LastUpdateTime?: Date;
+}
+export declare namespace DescribeGlobalSettingsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeGlobalSettingsOutput) => any;
+}
+export interface DescribeProtectedResourceInput {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace DescribeProtectedResourceInput {
+    
+    const filterSensitiveLog: (obj: DescribeProtectedResourceInput) => any;
+}
+export interface DescribeProtectedResourceOutput {
+    
+    ResourceArn?: string;
+    
+    ResourceType?: string;
+    
+    LastBackupTime?: Date;
+}
+export declare namespace DescribeProtectedResourceOutput {
+    
+    const filterSensitiveLog: (obj: DescribeProtectedResourceOutput) => any;
+}
+export interface DescribeRecoveryPointInput {
+    
+    BackupVaultName: string | undefined;
+    
+    RecoveryPointArn: string | undefined;
+}
+export declare namespace DescribeRecoveryPointInput {
+    
+    const filterSensitiveLog: (obj: DescribeRecoveryPointInput) => any;
+}
+export declare enum RecoveryPointStatus {
+    COMPLETED = "COMPLETED",
+    DELETING = "DELETING",
+    EXPIRED = "EXPIRED",
+    PARTIAL = "PARTIAL"
+}
+export declare enum StorageClass {
+    COLD = "COLD",
+    DELETED = "DELETED",
+    WARM = "WARM"
+}
+export interface DescribeRecoveryPointOutput {
+    
+    RecoveryPointArn?: string;
+    
+    BackupVaultName?: string;
+    
+    BackupVaultArn?: string;
+    
+    SourceBackupVaultArn?: string;
+    
+    ResourceArn?: string;
+    
+    ResourceType?: string;
+    
+    CreatedBy?: RecoveryPointCreator;
+    
+    IamRoleArn?: string;
+    
+    Status?: RecoveryPointStatus | string;
+    
+    StatusMessage?: string;
+    
+    CreationDate?: Date;
+    
+    CompletionDate?: Date;
+    
+    BackupSizeInBytes?: number;
+    
+    CalculatedLifecycle?: CalculatedLifecycle;
+    
+    Lifecycle?: Lifecycle;
+    
+    EncryptionKeyArn?: string;
+    
+    IsEncrypted?: boolean;
+    
+    StorageClass?: StorageClass | string;
+    
+    LastRestoreTime?: Date;
+}
+export declare namespace DescribeRecoveryPointOutput {
+    
+    const filterSensitiveLog: (obj: DescribeRecoveryPointOutput) => any;
+}
+export interface DescribeRegionSettingsInput {
+}
+export declare namespace DescribeRegionSettingsInput {
+    
+    const filterSensitiveLog: (obj: DescribeRegionSettingsInput) => any;
+}
+export interface DescribeRegionSettingsOutput {
+    
+    ResourceTypeOptInPreference?: {
+        [key: string]: boolean;
+    };
+    
+    ResourceTypeManagementPreference?: {
+        [key: string]: boolean;
+    };
+}
+export declare namespace DescribeRegionSettingsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeRegionSettingsOutput) => any;
+}
+export interface DescribeReportJobInput {
+    
+    ReportJobId: string | undefined;
+}
+export declare namespace DescribeReportJobInput {
+    
+    const filterSensitiveLog: (obj: DescribeReportJobInput) => any;
+}
+
+export interface ReportDestination {
+    
+    S3BucketName?: string;
+    
+    S3Keys?: string[];
+}
+export declare namespace ReportDestination {
+    
+    const filterSensitiveLog: (obj: ReportDestination) => any;
+}
+
+export interface ReportJob {
+    
+    ReportJobId?: string;
+    
+    ReportPlanArn?: string;
+    
+    ReportTemplate?: string;
+    
+    CreationTime?: Date;
+    
+    CompletionTime?: Date;
+    
+    Status?: string;
+    
+    StatusMessage?: string;
+    
+    ReportDestination?: ReportDestination;
+}
+export declare namespace ReportJob {
+    
+    const filterSensitiveLog: (obj: ReportJob) => any;
+}
+export interface DescribeReportJobOutput {
+    
+    ReportJob?: ReportJob;
+}
+export declare namespace DescribeReportJobOutput {
+    
+    const filterSensitiveLog: (obj: DescribeReportJobOutput) => any;
+}
+export interface DescribeReportPlanInput {
+    
+    ReportPlanName: string | undefined;
+}
+export declare namespace DescribeReportPlanInput {
+    
+    const filterSensitiveLog: (obj: DescribeReportPlanInput) => any;
+}
+
+export interface ReportPlan {
+    
+    ReportPlanArn?: string;
+    
+    ReportPlanName?: string;
+    
+    ReportPlanDescription?: string;
+    
+    ReportSetting?: ReportSetting;
+    
+    ReportDeliveryChannel?: ReportDeliveryChannel;
+    
+    DeploymentStatus?: string;
+    
+    CreationTime?: Date;
+    
+    LastAttemptedExecutionTime?: Date;
+    
+    LastSuccessfulExecutionTime?: Date;
+}
+export declare namespace ReportPlan {
+    
+    const filterSensitiveLog: (obj: ReportPlan) => any;
+}
+export interface DescribeReportPlanOutput {
+    
+    ReportPlan?: ReportPlan;
+}
+export declare namespace DescribeReportPlanOutput {
+    
+    const filterSensitiveLog: (obj: DescribeReportPlanOutput) => any;
+}
+export interface DescribeRestoreJobInput {
+    
+    RestoreJobId: string | undefined;
+}
+export declare namespace DescribeRestoreJobInput {
+    
+    const filterSensitiveLog: (obj: DescribeRestoreJobInput) => any;
+}
+export declare enum RestoreJobStatus {
+    ABORTED = "ABORTED",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    RUNNING = "RUNNING"
+}
+export interface DescribeRestoreJobOutput {
+    
+    AccountId?: string;
+    
+    RestoreJobId?: string;
+    
+    RecoveryPointArn?: string;
+    
+    CreationDate?: Date;
+    
+    CompletionDate?: Date;
+    
+    Status?: RestoreJobStatus | string;
+    
+    StatusMessage?: string;
+    
+    PercentDone?: string;
+    
+    BackupSizeInBytes?: number;
+    
+    IamRoleArn?: string;
+    
+    ExpectedCompletionTimeMinutes?: number;
+    
+    CreatedResourceArn?: string;
+    
+    ResourceType?: string;
+}
+export declare namespace DescribeRestoreJobOutput {
+    
+    const filterSensitiveLog: (obj: DescribeRestoreJobOutput) => any;
+}
+export interface DisassociateRecoveryPointInput {
+    
+    BackupVaultName: string | undefined;
+    
+    RecoveryPointArn: string | undefined;
+}
+export declare namespace DisassociateRecoveryPointInput {
+    
+    const filterSensitiveLog: (obj: DisassociateRecoveryPointInput) => any;
+}
+export interface ExportBackupPlanTemplateInput {
+    
+    BackupPlanId: string | undefined;
+}
+export declare namespace ExportBackupPlanTemplateInput {
+    
+    const filterSensitiveLog: (obj: ExportBackupPlanTemplateInput) => any;
+}
+export interface ExportBackupPlanTemplateOutput {
+    
+    BackupPlanTemplateJson?: string;
+}
+export declare namespace ExportBackupPlanTemplateOutput {
+    
+    const filterSensitiveLog: (obj: ExportBackupPlanTemplateOutput) => any;
+}
+export interface GetBackupPlanInput {
+    
+    BackupPlanId: string | undefined;
+    
+    VersionId?: string;
+}
+export declare namespace GetBackupPlanInput {
+    
+    const filterSensitiveLog: (obj: GetBackupPlanInput) => any;
+}
+export interface GetBackupPlanOutput {
+    
+    BackupPlan?: BackupPlan;
+    
+    BackupPlanId?: string;
+    
+    BackupPlanArn?: string;
+    
+    VersionId?: string;
+    
+    CreatorRequestId?: string;
+    
+    CreationDate?: Date;
+    
+    DeletionDate?: Date;
+    
+    LastExecutionDate?: Date;
+    
+    AdvancedBackupSettings?: AdvancedBackupSetting[];
+}
+export declare namespace GetBackupPlanOutput {
+    
+    const filterSensitiveLog: (obj: GetBackupPlanOutput) => any;
+}
+export interface GetBackupPlanFromJSONInput {
+    
+    BackupPlanTemplateJson: string | undefined;
+}
+export declare namespace GetBackupPlanFromJSONInput {
+    
+    const filterSensitiveLog: (obj: GetBackupPlanFromJSONInput) => any;
+}
+export interface GetBackupPlanFromJSONOutput {
+    
+    BackupPlan?: BackupPlan;
+}
+export declare namespace GetBackupPlanFromJSONOutput {
+    
+    const filterSensitiveLog: (obj: GetBackupPlanFromJSONOutput) => any;
+}
+export interface GetBackupPlanFromTemplateInput {
+    
+    BackupPlanTemplateId: string | undefined;
+}
+export declare namespace GetBackupPlanFromTemplateInput {
+    
+    const filterSensitiveLog: (obj: GetBackupPlanFromTemplateInput) => any;
+}
+export interface GetBackupPlanFromTemplateOutput {
+    
+    BackupPlanDocument?: BackupPlan;
+}
+export declare namespace GetBackupPlanFromTemplateOutput {
+    
+    const filterSensitiveLog: (obj: GetBackupPlanFromTemplateOutput) => any;
+}
+export interface GetBackupSelectionInput {
+    
+    BackupPlanId: string | undefined;
+    
+    SelectionId: string | undefined;
+}
+export declare namespace GetBackupSelectionInput {
+    
+    const filterSensitiveLog: (obj: GetBackupSelectionInput) => any;
+}
+export interface GetBackupSelectionOutput {
+    
+    BackupSelection?: BackupSelection;
+    
+    SelectionId?: string;
+    
+    BackupPlanId?: string;
+    
+    CreationDate?: Date;
+    
+    CreatorRequestId?: string;
+}
+export declare namespace GetBackupSelectionOutput {
+    
+    const filterSensitiveLog: (obj: GetBackupSelectionOutput) => any;
+}
+export interface GetBackupVaultAccessPolicyInput {
+    
+    BackupVaultName: string | undefined;
+}
+export declare namespace GetBackupVaultAccessPolicyInput {
+    
+    const filterSensitiveLog: (obj: GetBackupVaultAccessPolicyInput) => any;
+}
+export interface GetBackupVaultAccessPolicyOutput {
+    
+    BackupVaultName?: string;
+    
+    BackupVaultArn?: string;
+    
+    Policy?: string;
+}
+export declare namespace GetBackupVaultAccessPolicyOutput {
+    
+    const filterSensitiveLog: (obj: GetBackupVaultAccessPolicyOutput) => any;
+}
+export interface GetBackupVaultNotificationsInput {
+    
+    BackupVaultName: string | undefined;
+}
+export declare namespace GetBackupVaultNotificationsInput {
+    
+    const filterSensitiveLog: (obj: GetBackupVaultNotificationsInput) => any;
+}
+export interface GetBackupVaultNotificationsOutput {
+    
+    BackupVaultName?: string;
+    
+    BackupVaultArn?: string;
+    
+    SNSTopicArn?: string;
+    
+    BackupVaultEvents?: (BackupVaultEvent | string)[];
+}
+export declare namespace GetBackupVaultNotificationsOutput {
+    
+    const filterSensitiveLog: (obj: GetBackupVaultNotificationsOutput) => any;
+}
+export interface GetRecoveryPointRestoreMetadataInput {
+    
+    BackupVaultName: string | undefined;
+    
+    RecoveryPointArn: string | undefined;
+}
+export declare namespace GetRecoveryPointRestoreMetadataInput {
+    
+    const filterSensitiveLog: (obj: GetRecoveryPointRestoreMetadataInput) => any;
+}
+export interface GetRecoveryPointRestoreMetadataOutput {
+    
+    BackupVaultArn?: string;
+    
+    RecoveryPointArn?: string;
+    
+    RestoreMetadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetRecoveryPointRestoreMetadataOutput {
+    
+    const filterSensitiveLog: (obj: GetRecoveryPointRestoreMetadataOutput) => any;
+}
+export interface GetSupportedResourceTypesOutput {
+    
+    ResourceTypes?: string[];
+}
+export declare namespace GetSupportedResourceTypesOutput {
+    
+    const filterSensitiveLog: (obj: GetSupportedResourceTypesOutput) => any;
+}
+export interface ListBackupJobsInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ByResourceArn?: string;
+    
+    ByState?: BackupJobState | string;
+    
+    ByBackupVaultName?: string;
+    
+    ByCreatedBefore?: Date;
+    
+    ByCreatedAfter?: Date;
+    
+    ByResourceType?: string;
+    
+    ByAccountId?: string;
+}
+export declare namespace ListBackupJobsInput {
+    
+    const filterSensitiveLog: (obj: ListBackupJobsInput) => any;
+}
+export interface ListBackupJobsOutput {
+    
+    BackupJobs?: BackupJob[];
+    
+    NextToken?: string;
+}
+export declare namespace ListBackupJobsOutput {
+    
+    const filterSensitiveLog: (obj: ListBackupJobsOutput) => any;
+}
+export interface ListBackupPlansInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    IncludeDeleted?: boolean;
+}
+export declare namespace ListBackupPlansInput {
+    
+    const filterSensitiveLog: (obj: ListBackupPlansInput) => any;
+}
+export interface ListBackupPlansOutput {
+    
+    NextToken?: string;
+    
+    BackupPlansList?: BackupPlansListMember[];
+}
+export declare namespace ListBackupPlansOutput {
+    
+    const filterSensitiveLog: (obj: ListBackupPlansOutput) => any;
+}
+export interface ListBackupPlanTemplatesInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListBackupPlanTemplatesInput {
+    
+    const filterSensitiveLog: (obj: ListBackupPlanTemplatesInput) => any;
+}
+export interface ListBackupPlanTemplatesOutput {
+    
+    NextToken?: string;
+    
+    BackupPlanTemplatesList?: BackupPlanTemplatesListMember[];
+}
+export declare namespace ListBackupPlanTemplatesOutput {
+    
+    const filterSensitiveLog: (obj: ListBackupPlanTemplatesOutput) => any;
+}
+export interface ListBackupPlanVersionsInput {
+    
+    BackupPlanId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListBackupPlanVersionsInput {
+    
+    const filterSensitiveLog: (obj: ListBackupPlanVersionsInput) => any;
+}
+export interface ListBackupPlanVersionsOutput {
+    
+    NextToken?: string;
+    
+    BackupPlanVersionsList?: BackupPlansListMember[];
+}
+export declare namespace ListBackupPlanVersionsOutput {
+    
+    const filterSensitiveLog: (obj: ListBackupPlanVersionsOutput) => any;
+}
+export interface ListBackupSelectionsInput {
+    
+    BackupPlanId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListBackupSelectionsInput {
+    
+    const filterSensitiveLog: (obj: ListBackupSelectionsInput) => any;
+}
+export interface ListBackupSelectionsOutput {
+    
+    NextToken?: string;
+    
+    BackupSelectionsList?: BackupSelectionsListMember[];
+}
+export declare namespace ListBackupSelectionsOutput {
+    
+    const filterSensitiveLog: (obj: ListBackupSelectionsOutput) => any;
+}
+export interface ListBackupVaultsInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListBackupVaultsInput {
+    
+    const filterSensitiveLog: (obj: ListBackupVaultsInput) => any;
+}
+export interface ListBackupVaultsOutput {
+    
+    BackupVaultList?: BackupVaultListMember[];
+    
+    NextToken?: string;
+}
+export declare namespace ListBackupVaultsOutput {
+    
+    const filterSensitiveLog: (obj: ListBackupVaultsOutput) => any;
+}
+export interface ListCopyJobsInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ByResourceArn?: string;
+    
+    ByState?: CopyJobState | string;
+    
+    ByCreatedBefore?: Date;
+    
+    ByCreatedAfter?: Date;
+    
+    ByResourceType?: string;
+    
+    ByDestinationVaultArn?: string;
+    
+    ByAccountId?: string;
+}
+export declare namespace ListCopyJobsInput {
+    
+    const filterSensitiveLog: (obj: ListCopyJobsInput) => any;
+}
+export interface ListCopyJobsOutput {
+    
+    CopyJobs?: CopyJob[];
+    
+    NextToken?: string;
+}
+export declare namespace ListCopyJobsOutput {
+    
+    const filterSensitiveLog: (obj: ListCopyJobsOutput) => any;
+}
+export interface ListFrameworksInput {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListFrameworksInput {
+    
+    const filterSensitiveLog: (obj: ListFrameworksInput) => any;
+}
+
+export interface Framework {
+    
+    FrameworkName?: string;
+    
+    FrameworkArn?: string;
+    
+    FrameworkDescription?: string;
+    
+    NumberOfControls?: number;
+    
+    CreationTime?: Date;
+    
+    DeploymentStatus?: string;
+}
+export declare namespace Framework {
+    
+    const filterSensitiveLog: (obj: Framework) => any;
+}
+export interface ListFrameworksOutput {
+    
+    Frameworks?: Framework[];
+    
+    NextToken?: string;
+}
+export declare namespace ListFrameworksOutput {
+    
+    const filterSensitiveLog: (obj: ListFrameworksOutput) => any;
+}
+export interface ListProtectedResourcesInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListProtectedResourcesInput {
+    
+    const filterSensitiveLog: (obj: ListProtectedResourcesInput) => any;
+}
+
+export interface ProtectedResource {
+    
+    ResourceArn?: string;
+    
+    ResourceType?: string;
+    
+    LastBackupTime?: Date;
+}
+export declare namespace ProtectedResource {
+    
+    const filterSensitiveLog: (obj: ProtectedResource) => any;
+}
+export interface ListProtectedResourcesOutput {
+    
+    Results?: ProtectedResource[];
+    
+    NextToken?: string;
+}
+export declare namespace ListProtectedResourcesOutput {
+    
+    const filterSensitiveLog: (obj: ListProtectedResourcesOutput) => any;
+}
+export interface ListRecoveryPointsByBackupVaultInput {
+    
+    BackupVaultName: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ByResourceArn?: string;
+    
+    ByResourceType?: string;
+    
+    ByBackupPlanId?: string;
+    
+    ByCreatedBefore?: Date;
+    
+    ByCreatedAfter?: Date;
+}
+export declare namespace ListRecoveryPointsByBackupVaultInput {
+    
+    const filterSensitiveLog: (obj: ListRecoveryPointsByBackupVaultInput) => any;
+}
+
+export interface RecoveryPointByBackupVault {
+    
+    RecoveryPointArn?: string;
+    
+    BackupVaultName?: string;
+    
+    BackupVaultArn?: string;
+    
+    SourceBackupVaultArn?: string;
+    
+    ResourceArn?: string;
+    
+    ResourceType?: string;
+    
+    CreatedBy?: RecoveryPointCreator;
+    
+    IamRoleArn?: string;
+    
+    Status?: RecoveryPointStatus | string;
+    
+    StatusMessage?: string;
+    
+    CreationDate?: Date;
+    
+    CompletionDate?: Date;
+    
+    BackupSizeInBytes?: number;
+    
+    CalculatedLifecycle?: CalculatedLifecycle;
+    
+    Lifecycle?: Lifecycle;
+    
+    EncryptionKeyArn?: string;
+    
+    IsEncrypted?: boolean;
+    
+    LastRestoreTime?: Date;
+}
+export declare namespace RecoveryPointByBackupVault {
+    
+    const filterSensitiveLog: (obj: RecoveryPointByBackupVault) => any;
+}
+export interface ListRecoveryPointsByBackupVaultOutput {
+    
+    NextToken?: string;
+    
+    RecoveryPoints?: RecoveryPointByBackupVault[];
+}
+export declare namespace ListRecoveryPointsByBackupVaultOutput {
+    
+    const filterSensitiveLog: (obj: ListRecoveryPointsByBackupVaultOutput) => any;
+}
+export interface ListRecoveryPointsByResourceInput {
+    
+    ResourceArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListRecoveryPointsByResourceInput {
+    
+    const filterSensitiveLog: (obj: ListRecoveryPointsByResourceInput) => any;
+}
+
+export interface RecoveryPointByResource {
+    
+    RecoveryPointArn?: string;
+    
+    CreationDate?: Date;
+    
+    Status?: RecoveryPointStatus | string;
+    
+    StatusMessage?: string;
+    
+    EncryptionKeyArn?: string;
+    
+    BackupSizeBytes?: number;
+    
+    BackupVaultName?: string;
+}
+export declare namespace RecoveryPointByResource {
+    
+    const filterSensitiveLog: (obj: RecoveryPointByResource) => any;
+}
+export interface ListRecoveryPointsByResourceOutput {
+    
+    NextToken?: string;
+    
+    RecoveryPoints?: RecoveryPointByResource[];
+}
+export declare namespace ListRecoveryPointsByResourceOutput {
+    
+    const filterSensitiveLog: (obj: ListRecoveryPointsByResourceOutput) => any;
+}
+export interface ListReportJobsInput {
+    
+    ByReportPlanName?: string;
+    
+    ByCreationBefore?: Date;
+    
+    ByCreationAfter?: Date;
+    
+    ByStatus?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListReportJobsInput {
+    
+    const filterSensitiveLog: (obj: ListReportJobsInput) => any;
+}
+export interface ListReportJobsOutput {
+    
+    ReportJobs?: ReportJob[];
+    
+    NextToken?: string;
+}
+export declare namespace ListReportJobsOutput {
+    
+    const filterSensitiveLog: (obj: ListReportJobsOutput) => any;
+}
+export interface ListReportPlansInput {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListReportPlansInput {
+    
+    const filterSensitiveLog: (obj: ListReportPlansInput) => any;
+}
+export interface ListReportPlansOutput {
+    
+    ReportPlans?: ReportPlan[];
+    
+    NextToken?: string;
+}
+export declare namespace ListReportPlansOutput {
+    
+    const filterSensitiveLog: (obj: ListReportPlansOutput) => any;
+}
+export interface ListRestoreJobsInput {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ByAccountId?: string;
+    
+    ByCreatedBefore?: Date;
+    
+    ByCreatedAfter?: Date;
+    
+    ByStatus?: RestoreJobStatus | string;
+}
+export declare namespace ListRestoreJobsInput {
+    
+    const filterSensitiveLog: (obj: ListRestoreJobsInput) => any;
+}
+
+export interface RestoreJobsListMember {
+    
+    AccountId?: string;
+    
+    RestoreJobId?: string;
+    
+    RecoveryPointArn?: string;
+    
+    CreationDate?: Date;
+    
+    CompletionDate?: Date;
+    
+    Status?: RestoreJobStatus | string;
+    
+    StatusMessage?: string;
+    
+    PercentDone?: string;
+    
+    BackupSizeInBytes?: number;
+    
+    IamRoleArn?: string;
+    
+    ExpectedCompletionTimeMinutes?: number;
+    
+    CreatedResourceArn?: string;
+    
+    ResourceType?: string;
+}
+export declare namespace RestoreJobsListMember {
+    
+    const filterSensitiveLog: (obj: RestoreJobsListMember) => any;
+}
+export interface ListRestoreJobsOutput {
+    
+    RestoreJobs?: RestoreJobsListMember[];
+    
+    NextToken?: string;
+}
+export declare namespace ListRestoreJobsOutput {
+    
+    const filterSensitiveLog: (obj: ListRestoreJobsOutput) => any;
+}
+export interface ListTagsInput {
+    
+    ResourceArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTagsInput {
+    
+    const filterSensitiveLog: (obj: ListTagsInput) => any;
+}
+export interface ListTagsOutput {
+    
+    NextToken?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsOutput {
+    
+    const filterSensitiveLog: (obj: ListTagsOutput) => any;
+}
+export interface PutBackupVaultAccessPolicyInput {
+    
+    BackupVaultName: string | undefined;
+    
+    Policy?: string;
+}
+export declare namespace PutBackupVaultAccessPolicyInput {
+    
+    const filterSensitiveLog: (obj: PutBackupVaultAccessPolicyInput) => any;
+}
+export interface PutBackupVaultLockConfigurationInput {
+    
+    BackupVaultName: string | undefined;
+    
+    MinRetentionDays?: number;
+    
+    MaxRetentionDays?: number;
+    
+    ChangeableForDays?: number;
+}
+export declare namespace PutBackupVaultLockConfigurationInput {
+    
+    const filterSensitiveLog: (obj: PutBackupVaultLockConfigurationInput) => any;
+}
+export interface PutBackupVaultNotificationsInput {
+    
+    BackupVaultName: string | undefined;
+    
+    SNSTopicArn: string | undefined;
+    
+    BackupVaultEvents: (BackupVaultEvent | string)[] | undefined;
+}
+export declare namespace PutBackupVaultNotificationsInput {
+    
+    const filterSensitiveLog: (obj: PutBackupVaultNotificationsInput) => any;
+}
+export interface StartBackupJobInput {
+    
+    BackupVaultName: string | undefined;
+    
+    ResourceArn: string | undefined;
+    
+    IamRoleArn: string | undefined;
+    
+    IdempotencyToken?: string;
+    
+    StartWindowMinutes?: number;
+    
+    CompleteWindowMinutes?: number;
+    
+    Lifecycle?: Lifecycle;
+    
+    RecoveryPointTags?: {
+        [key: string]: string;
+    };
+    
+    BackupOptions?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StartBackupJobInput {
+    
+    const filterSensitiveLog: (obj: StartBackupJobInput) => any;
+}
+export interface StartBackupJobOutput {
+    
+    BackupJobId?: string;
+    
+    RecoveryPointArn?: string;
+    
+    CreationDate?: Date;
+}
+export declare namespace StartBackupJobOutput {
+    
+    const filterSensitiveLog: (obj: StartBackupJobOutput) => any;
+}
+export interface StartCopyJobInput {
+    
+    RecoveryPointArn: string | undefined;
+    
+    SourceBackupVaultName: string | undefined;
+    
+    DestinationBackupVaultArn: string | undefined;
+    
+    IamRoleArn: string | undefined;
+    
+    IdempotencyToken?: string;
+    
+    Lifecycle?: Lifecycle;
+}
+export declare namespace StartCopyJobInput {
+    
+    const filterSensitiveLog: (obj: StartCopyJobInput) => any;
+}
+export interface StartCopyJobOutput {
+    
+    CopyJobId?: string;
+    
+    CreationDate?: Date;
+}
+export declare namespace StartCopyJobOutput {
+    
+    const filterSensitiveLog: (obj: StartCopyJobOutput) => any;
+}
+export interface StartReportJobInput {
+    
+    ReportPlanName: string | undefined;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace StartReportJobInput {
+    
+    const filterSensitiveLog: (obj: StartReportJobInput) => any;
+}
+export interface StartReportJobOutput {
+    
+    ReportJobId?: string;
+}
+export declare namespace StartReportJobOutput {
+    
+    const filterSensitiveLog: (obj: StartReportJobOutput) => any;
+}
+export interface StartRestoreJobInput {
+    
+    RecoveryPointArn: string | undefined;
+    
+    Metadata: {
+        [key: string]: string;
+    } | undefined;
+    
+    IamRoleArn: string | undefined;
+    
+    IdempotencyToken?: string;
+    
+    ResourceType?: string;
+}
+export declare namespace StartRestoreJobInput {
+    
+    const filterSensitiveLog: (obj: StartRestoreJobInput) => any;
+}
+export interface StartRestoreJobOutput {
+    
+    RestoreJobId?: string;
+}
+export declare namespace StartRestoreJobOutput {
+    
+    const filterSensitiveLog: (obj: StartRestoreJobOutput) => any;
+}
+export interface StopBackupJobInput {
+    
+    BackupJobId: string | undefined;
+}
+export declare namespace StopBackupJobInput {
+    
+    const filterSensitiveLog: (obj: StopBackupJobInput) => any;
+}
+export interface TagResourceInput {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceInput {
+    
+    const filterSensitiveLog: (obj: TagResourceInput) => any;
+}
+export interface UntagResourceInput {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeyList: string[] | undefined;
+}
+export declare namespace UntagResourceInput {
+    
+    const filterSensitiveLog: (obj: UntagResourceInput) => any;
+}
+export interface UpdateBackupPlanInput {
+    
+    BackupPlanId: string | undefined;
+    
+    BackupPlan: BackupPlanInput | undefined;
+}
+export declare namespace UpdateBackupPlanInput {
+    
+    const filterSensitiveLog: (obj: UpdateBackupPlanInput) => any;
+}
+export interface UpdateBackupPlanOutput {
+    
+    BackupPlanId?: string;
+    
+    BackupPlanArn?: string;
+    
+    CreationDate?: Date;
+    
+    VersionId?: string;
+    
+    AdvancedBackupSettings?: AdvancedBackupSetting[];
+}
+export declare namespace UpdateBackupPlanOutput {
+    
+    const filterSensitiveLog: (obj: UpdateBackupPlanOutput) => any;
+}
+export interface UpdateFrameworkInput {
+    
+    FrameworkName: string | undefined;
+    
+    FrameworkDescription?: string;
+    
+    FrameworkControls?: FrameworkControl[];
+    
+    IdempotencyToken?: string;
+}
+export declare namespace UpdateFrameworkInput {
+    
+    const filterSensitiveLog: (obj: UpdateFrameworkInput) => any;
+}
+export interface UpdateFrameworkOutput {
+    
+    FrameworkName?: string;
+    
+    FrameworkArn?: string;
+    
+    CreationTime?: Date;
+}
+export declare namespace UpdateFrameworkOutput {
+    
+    const filterSensitiveLog: (obj: UpdateFrameworkOutput) => any;
+}
+export interface UpdateGlobalSettingsInput {
+    
+    GlobalSettings?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UpdateGlobalSettingsInput {
+    
+    const filterSensitiveLog: (obj: UpdateGlobalSettingsInput) => any;
+}
+export interface UpdateRecoveryPointLifecycleInput {
+    
+    BackupVaultName: string | undefined;
+    
+    RecoveryPointArn: string | undefined;
+    
+    Lifecycle?: Lifecycle;
+}
+export declare namespace UpdateRecoveryPointLifecycleInput {
+    
+    const filterSensitiveLog: (obj: UpdateRecoveryPointLifecycleInput) => any;
+}
+export interface UpdateRecoveryPointLifecycleOutput {
+    
+    BackupVaultArn?: string;
+    
+    RecoveryPointArn?: string;
+    
+    Lifecycle?: Lifecycle;
+    
+    CalculatedLifecycle?: CalculatedLifecycle;
+}
+export declare namespace UpdateRecoveryPointLifecycleOutput {
+    
+    const filterSensitiveLog: (obj: UpdateRecoveryPointLifecycleOutput) => any;
+}
+export interface UpdateRegionSettingsInput {
+    
+    ResourceTypeOptInPreference?: {
+        [key: string]: boolean;
+    };
+    
+    ResourceTypeManagementPreference?: {
+        [key: string]: boolean;
+    };
+}
+export declare namespace UpdateRegionSettingsInput {
+    
+    const filterSensitiveLog: (obj: UpdateRegionSettingsInput) => any;
+}
+export interface UpdateReportPlanInput {
+    
+    ReportPlanName: string | undefined;
+    
+    ReportPlanDescription?: string;
+    
+    ReportDeliveryChannel?: ReportDeliveryChannel;
+    
+    ReportSetting?: ReportSetting;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace UpdateReportPlanInput {
+    
+    const filterSensitiveLog: (obj: UpdateReportPlanInput) => any;
+}
+export interface UpdateReportPlanOutput {
+    
+    ReportPlanName?: string;
+    
+    ReportPlanArn?: string;
+    
+    CreationTime?: Date;
+}
+export declare namespace UpdateReportPlanOutput {
+    
+    const filterSensitiveLog: (obj: UpdateReportPlanOutput) => any;
+}