@aws-sdk/client-backup 3.183.0 → 3.186.0

package/dist-es/Backup.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { BackupClient } from "./BackupClient";
 import { CreateBackupPlanCommand, } from "./commands/CreateBackupPlanCommand";
 import { CreateBackupSelectionCommand, } from "./commands/CreateBackupSelectionCommand";
@@ -65,929 +66,935 @@ import { UpdateGlobalSettingsCommand, } from "./commands/UpdateGlobalSettingsCom
 import { UpdateRecoveryPointLifecycleCommand, } from "./commands/UpdateRecoveryPointLifecycleCommand";
 import { UpdateRegionSettingsCommand, } from "./commands/UpdateRegionSettingsCommand";
 import { UpdateReportPlanCommand, } from "./commands/UpdateReportPlanCommand";
-export class Backup extends BackupClient {
-    createBackupPlan(args, optionsOrCb, cb) {
-        const command = new CreateBackupPlanCommand(args);
+var Backup = (function (_super) {
+    __extends(Backup, _super);
+    function Backup() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Backup.prototype.createBackupPlan = function (args, optionsOrCb, cb) {
+        var command = new CreateBackupPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createBackupSelection(args, optionsOrCb, cb) {
-        const command = new CreateBackupSelectionCommand(args);
+    };
+    Backup.prototype.createBackupSelection = function (args, optionsOrCb, cb) {
+        var command = new CreateBackupSelectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createBackupVault(args, optionsOrCb, cb) {
-        const command = new CreateBackupVaultCommand(args);
+    };
+    Backup.prototype.createBackupVault = function (args, optionsOrCb, cb) {
+        var command = new CreateBackupVaultCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createFramework(args, optionsOrCb, cb) {
-        const command = new CreateFrameworkCommand(args);
+    };
+    Backup.prototype.createFramework = function (args, optionsOrCb, cb) {
+        var command = new CreateFrameworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createReportPlan(args, optionsOrCb, cb) {
-        const command = new CreateReportPlanCommand(args);
+    };
+    Backup.prototype.createReportPlan = function (args, optionsOrCb, cb) {
+        var command = new CreateReportPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteBackupPlan(args, optionsOrCb, cb) {
-        const command = new DeleteBackupPlanCommand(args);
+    };
+    Backup.prototype.deleteBackupPlan = function (args, optionsOrCb, cb) {
+        var command = new DeleteBackupPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteBackupSelection(args, optionsOrCb, cb) {
-        const command = new DeleteBackupSelectionCommand(args);
+    };
+    Backup.prototype.deleteBackupSelection = function (args, optionsOrCb, cb) {
+        var command = new DeleteBackupSelectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteBackupVault(args, optionsOrCb, cb) {
-        const command = new DeleteBackupVaultCommand(args);
+    };
+    Backup.prototype.deleteBackupVault = function (args, optionsOrCb, cb) {
+        var command = new DeleteBackupVaultCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteBackupVaultAccessPolicy(args, optionsOrCb, cb) {
-        const command = new DeleteBackupVaultAccessPolicyCommand(args);
+    };
+    Backup.prototype.deleteBackupVaultAccessPolicy = function (args, optionsOrCb, cb) {
+        var command = new DeleteBackupVaultAccessPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteBackupVaultLockConfiguration(args, optionsOrCb, cb) {
-        const command = new DeleteBackupVaultLockConfigurationCommand(args);
+    };
+    Backup.prototype.deleteBackupVaultLockConfiguration = function (args, optionsOrCb, cb) {
+        var command = new DeleteBackupVaultLockConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteBackupVaultNotifications(args, optionsOrCb, cb) {
-        const command = new DeleteBackupVaultNotificationsCommand(args);
+    };
+    Backup.prototype.deleteBackupVaultNotifications = function (args, optionsOrCb, cb) {
+        var command = new DeleteBackupVaultNotificationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteFramework(args, optionsOrCb, cb) {
-        const command = new DeleteFrameworkCommand(args);
+    };
+    Backup.prototype.deleteFramework = function (args, optionsOrCb, cb) {
+        var command = new DeleteFrameworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteRecoveryPoint(args, optionsOrCb, cb) {
-        const command = new DeleteRecoveryPointCommand(args);
+    };
+    Backup.prototype.deleteRecoveryPoint = function (args, optionsOrCb, cb) {
+        var command = new DeleteRecoveryPointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteReportPlan(args, optionsOrCb, cb) {
-        const command = new DeleteReportPlanCommand(args);
+    };
+    Backup.prototype.deleteReportPlan = function (args, optionsOrCb, cb) {
+        var command = new DeleteReportPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeBackupJob(args, optionsOrCb, cb) {
-        const command = new DescribeBackupJobCommand(args);
+    };
+    Backup.prototype.describeBackupJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeBackupJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeBackupVault(args, optionsOrCb, cb) {
-        const command = new DescribeBackupVaultCommand(args);
+    };
+    Backup.prototype.describeBackupVault = function (args, optionsOrCb, cb) {
+        var command = new DescribeBackupVaultCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeCopyJob(args, optionsOrCb, cb) {
-        const command = new DescribeCopyJobCommand(args);
+    };
+    Backup.prototype.describeCopyJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeCopyJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeFramework(args, optionsOrCb, cb) {
-        const command = new DescribeFrameworkCommand(args);
+    };
+    Backup.prototype.describeFramework = function (args, optionsOrCb, cb) {
+        var command = new DescribeFrameworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeGlobalSettings(args, optionsOrCb, cb) {
-        const command = new DescribeGlobalSettingsCommand(args);
+    };
+    Backup.prototype.describeGlobalSettings = function (args, optionsOrCb, cb) {
+        var command = new DescribeGlobalSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeProtectedResource(args, optionsOrCb, cb) {
-        const command = new DescribeProtectedResourceCommand(args);
+    };
+    Backup.prototype.describeProtectedResource = function (args, optionsOrCb, cb) {
+        var command = new DescribeProtectedResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeRecoveryPoint(args, optionsOrCb, cb) {
-        const command = new DescribeRecoveryPointCommand(args);
+    };
+    Backup.prototype.describeRecoveryPoint = function (args, optionsOrCb, cb) {
+        var command = new DescribeRecoveryPointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeRegionSettings(args, optionsOrCb, cb) {
-        const command = new DescribeRegionSettingsCommand(args);
+    };
+    Backup.prototype.describeRegionSettings = function (args, optionsOrCb, cb) {
+        var command = new DescribeRegionSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeReportJob(args, optionsOrCb, cb) {
-        const command = new DescribeReportJobCommand(args);
+    };
+    Backup.prototype.describeReportJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeReportJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeReportPlan(args, optionsOrCb, cb) {
-        const command = new DescribeReportPlanCommand(args);
+    };
+    Backup.prototype.describeReportPlan = function (args, optionsOrCb, cb) {
+        var command = new DescribeReportPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeRestoreJob(args, optionsOrCb, cb) {
-        const command = new DescribeRestoreJobCommand(args);
+    };
+    Backup.prototype.describeRestoreJob = function (args, optionsOrCb, cb) {
+        var command = new DescribeRestoreJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disassociateRecoveryPoint(args, optionsOrCb, cb) {
-        const command = new DisassociateRecoveryPointCommand(args);
+    };
+    Backup.prototype.disassociateRecoveryPoint = function (args, optionsOrCb, cb) {
+        var command = new DisassociateRecoveryPointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    exportBackupPlanTemplate(args, optionsOrCb, cb) {
-        const command = new ExportBackupPlanTemplateCommand(args);
+    };
+    Backup.prototype.exportBackupPlanTemplate = function (args, optionsOrCb, cb) {
+        var command = new ExportBackupPlanTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBackupPlan(args, optionsOrCb, cb) {
-        const command = new GetBackupPlanCommand(args);
+    };
+    Backup.prototype.getBackupPlan = function (args, optionsOrCb, cb) {
+        var command = new GetBackupPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBackupPlanFromJSON(args, optionsOrCb, cb) {
-        const command = new GetBackupPlanFromJSONCommand(args);
+    };
+    Backup.prototype.getBackupPlanFromJSON = function (args, optionsOrCb, cb) {
+        var command = new GetBackupPlanFromJSONCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBackupPlanFromTemplate(args, optionsOrCb, cb) {
-        const command = new GetBackupPlanFromTemplateCommand(args);
+    };
+    Backup.prototype.getBackupPlanFromTemplate = function (args, optionsOrCb, cb) {
+        var command = new GetBackupPlanFromTemplateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBackupSelection(args, optionsOrCb, cb) {
-        const command = new GetBackupSelectionCommand(args);
+    };
+    Backup.prototype.getBackupSelection = function (args, optionsOrCb, cb) {
+        var command = new GetBackupSelectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBackupVaultAccessPolicy(args, optionsOrCb, cb) {
-        const command = new GetBackupVaultAccessPolicyCommand(args);
+    };
+    Backup.prototype.getBackupVaultAccessPolicy = function (args, optionsOrCb, cb) {
+        var command = new GetBackupVaultAccessPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBackupVaultNotifications(args, optionsOrCb, cb) {
-        const command = new GetBackupVaultNotificationsCommand(args);
+    };
+    Backup.prototype.getBackupVaultNotifications = function (args, optionsOrCb, cb) {
+        var command = new GetBackupVaultNotificationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRecoveryPointRestoreMetadata(args, optionsOrCb, cb) {
-        const command = new GetRecoveryPointRestoreMetadataCommand(args);
+    };
+    Backup.prototype.getRecoveryPointRestoreMetadata = function (args, optionsOrCb, cb) {
+        var command = new GetRecoveryPointRestoreMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSupportedResourceTypes(args, optionsOrCb, cb) {
-        const command = new GetSupportedResourceTypesCommand(args);
+    };
+    Backup.prototype.getSupportedResourceTypes = function (args, optionsOrCb, cb) {
+        var command = new GetSupportedResourceTypesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listBackupJobs(args, optionsOrCb, cb) {
-        const command = new ListBackupJobsCommand(args);
+    };
+    Backup.prototype.listBackupJobs = function (args, optionsOrCb, cb) {
+        var command = new ListBackupJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listBackupPlans(args, optionsOrCb, cb) {
-        const command = new ListBackupPlansCommand(args);
+    };
+    Backup.prototype.listBackupPlans = function (args, optionsOrCb, cb) {
+        var command = new ListBackupPlansCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listBackupPlanTemplates(args, optionsOrCb, cb) {
-        const command = new ListBackupPlanTemplatesCommand(args);
+    };
+    Backup.prototype.listBackupPlanTemplates = function (args, optionsOrCb, cb) {
+        var command = new ListBackupPlanTemplatesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listBackupPlanVersions(args, optionsOrCb, cb) {
-        const command = new ListBackupPlanVersionsCommand(args);
+    };
+    Backup.prototype.listBackupPlanVersions = function (args, optionsOrCb, cb) {
+        var command = new ListBackupPlanVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listBackupSelections(args, optionsOrCb, cb) {
-        const command = new ListBackupSelectionsCommand(args);
+    };
+    Backup.prototype.listBackupSelections = function (args, optionsOrCb, cb) {
+        var command = new ListBackupSelectionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listBackupVaults(args, optionsOrCb, cb) {
-        const command = new ListBackupVaultsCommand(args);
+    };
+    Backup.prototype.listBackupVaults = function (args, optionsOrCb, cb) {
+        var command = new ListBackupVaultsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCopyJobs(args, optionsOrCb, cb) {
-        const command = new ListCopyJobsCommand(args);
+    };
+    Backup.prototype.listCopyJobs = function (args, optionsOrCb, cb) {
+        var command = new ListCopyJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listFrameworks(args, optionsOrCb, cb) {
-        const command = new ListFrameworksCommand(args);
+    };
+    Backup.prototype.listFrameworks = function (args, optionsOrCb, cb) {
+        var command = new ListFrameworksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listProtectedResources(args, optionsOrCb, cb) {
-        const command = new ListProtectedResourcesCommand(args);
+    };
+    Backup.prototype.listProtectedResources = function (args, optionsOrCb, cb) {
+        var command = new ListProtectedResourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listRecoveryPointsByBackupVault(args, optionsOrCb, cb) {
-        const command = new ListRecoveryPointsByBackupVaultCommand(args);
+    };
+    Backup.prototype.listRecoveryPointsByBackupVault = function (args, optionsOrCb, cb) {
+        var command = new ListRecoveryPointsByBackupVaultCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listRecoveryPointsByResource(args, optionsOrCb, cb) {
-        const command = new ListRecoveryPointsByResourceCommand(args);
+    };
+    Backup.prototype.listRecoveryPointsByResource = function (args, optionsOrCb, cb) {
+        var command = new ListRecoveryPointsByResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listReportJobs(args, optionsOrCb, cb) {
-        const command = new ListReportJobsCommand(args);
+    };
+    Backup.prototype.listReportJobs = function (args, optionsOrCb, cb) {
+        var command = new ListReportJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listReportPlans(args, optionsOrCb, cb) {
-        const command = new ListReportPlansCommand(args);
+    };
+    Backup.prototype.listReportPlans = function (args, optionsOrCb, cb) {
+        var command = new ListReportPlansCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listRestoreJobs(args, optionsOrCb, cb) {
-        const command = new ListRestoreJobsCommand(args);
+    };
+    Backup.prototype.listRestoreJobs = function (args, optionsOrCb, cb) {
+        var command = new ListRestoreJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTags(args, optionsOrCb, cb) {
-        const command = new ListTagsCommand(args);
+    };
+    Backup.prototype.listTags = function (args, optionsOrCb, cb) {
+        var command = new ListTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putBackupVaultAccessPolicy(args, optionsOrCb, cb) {
-        const command = new PutBackupVaultAccessPolicyCommand(args);
+    };
+    Backup.prototype.putBackupVaultAccessPolicy = function (args, optionsOrCb, cb) {
+        var command = new PutBackupVaultAccessPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putBackupVaultLockConfiguration(args, optionsOrCb, cb) {
-        const command = new PutBackupVaultLockConfigurationCommand(args);
+    };
+    Backup.prototype.putBackupVaultLockConfiguration = function (args, optionsOrCb, cb) {
+        var command = new PutBackupVaultLockConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putBackupVaultNotifications(args, optionsOrCb, cb) {
-        const command = new PutBackupVaultNotificationsCommand(args);
+    };
+    Backup.prototype.putBackupVaultNotifications = function (args, optionsOrCb, cb) {
+        var command = new PutBackupVaultNotificationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startBackupJob(args, optionsOrCb, cb) {
-        const command = new StartBackupJobCommand(args);
+    };
+    Backup.prototype.startBackupJob = function (args, optionsOrCb, cb) {
+        var command = new StartBackupJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startCopyJob(args, optionsOrCb, cb) {
-        const command = new StartCopyJobCommand(args);
+    };
+    Backup.prototype.startCopyJob = function (args, optionsOrCb, cb) {
+        var command = new StartCopyJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startReportJob(args, optionsOrCb, cb) {
-        const command = new StartReportJobCommand(args);
+    };
+    Backup.prototype.startReportJob = function (args, optionsOrCb, cb) {
+        var command = new StartReportJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startRestoreJob(args, optionsOrCb, cb) {
-        const command = new StartRestoreJobCommand(args);
+    };
+    Backup.prototype.startRestoreJob = function (args, optionsOrCb, cb) {
+        var command = new StartRestoreJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopBackupJob(args, optionsOrCb, cb) {
-        const command = new StopBackupJobCommand(args);
+    };
+    Backup.prototype.stopBackupJob = function (args, optionsOrCb, cb) {
+        var command = new StopBackupJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
+    };
+    Backup.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    Backup.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateBackupPlan(args, optionsOrCb, cb) {
-        const command = new UpdateBackupPlanCommand(args);
+    };
+    Backup.prototype.updateBackupPlan = function (args, optionsOrCb, cb) {
+        var command = new UpdateBackupPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateFramework(args, optionsOrCb, cb) {
-        const command = new UpdateFrameworkCommand(args);
+    };
+    Backup.prototype.updateFramework = function (args, optionsOrCb, cb) {
+        var command = new UpdateFrameworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateGlobalSettings(args, optionsOrCb, cb) {
-        const command = new UpdateGlobalSettingsCommand(args);
+    };
+    Backup.prototype.updateGlobalSettings = function (args, optionsOrCb, cb) {
+        var command = new UpdateGlobalSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateRecoveryPointLifecycle(args, optionsOrCb, cb) {
-        const command = new UpdateRecoveryPointLifecycleCommand(args);
+    };
+    Backup.prototype.updateRecoveryPointLifecycle = function (args, optionsOrCb, cb) {
+        var command = new UpdateRecoveryPointLifecycleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateRegionSettings(args, optionsOrCb, cb) {
-        const command = new UpdateRegionSettingsCommand(args);
+    };
+    Backup.prototype.updateRegionSettings = function (args, optionsOrCb, cb) {
+        var command = new UpdateRegionSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateReportPlan(args, optionsOrCb, cb) {
-        const command = new UpdateReportPlanCommand(args);
+    };
+    Backup.prototype.updateReportPlan = function (args, optionsOrCb, cb) {
+        var command = new UpdateReportPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return Backup;
+}(BackupClient));
+export { Backup };