@aws-sdk/client-rds 3.183.0 → 3.185.0

package/dist-es/RDS.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { AddRoleToDBClusterCommand, } from "./commands/AddRoleToDBClusterCommand";
 import { AddRoleToDBInstanceCommand, } from "./commands/AddRoleToDBInstanceCommand";
 import { AddSourceIdentifierToSubscriptionCommand, } from "./commands/AddSourceIdentifierToSubscriptionCommand";
@@ -136,1923 +137,1929 @@ import { StopDBInstanceAutomatedBackupsReplicationCommand, } from "./commands/St
 import { StopDBInstanceCommand, } from "./commands/StopDBInstanceCommand";
 import { SwitchoverReadReplicaCommand, } from "./commands/SwitchoverReadReplicaCommand";
 import { RDSClient } from "./RDSClient";
-export class RDS extends RDSClient {
-    addRoleToDBCluster(args, optionsOrCb, cb) {
-        const command = new AddRoleToDBClusterCommand(args);
+var RDS = (function (_super) {
+    __extends(RDS, _super);
+    function RDS() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RDS.prototype.addRoleToDBCluster = function (args, optionsOrCb, cb) {
+        var command = new AddRoleToDBClusterCommand(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);
         }
-    }
-    addRoleToDBInstance(args, optionsOrCb, cb) {
-        const command = new AddRoleToDBInstanceCommand(args);
+    };
+    RDS.prototype.addRoleToDBInstance = function (args, optionsOrCb, cb) {
+        var command = new AddRoleToDBInstanceCommand(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);
         }
-    }
-    addSourceIdentifierToSubscription(args, optionsOrCb, cb) {
-        const command = new AddSourceIdentifierToSubscriptionCommand(args);
+    };
+    RDS.prototype.addSourceIdentifierToSubscription = function (args, optionsOrCb, cb) {
+        var command = new AddSourceIdentifierToSubscriptionCommand(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);
         }
-    }
-    addTagsToResource(args, optionsOrCb, cb) {
-        const command = new AddTagsToResourceCommand(args);
+    };
+    RDS.prototype.addTagsToResource = function (args, optionsOrCb, cb) {
+        var command = new AddTagsToResourceCommand(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);
         }
-    }
-    applyPendingMaintenanceAction(args, optionsOrCb, cb) {
-        const command = new ApplyPendingMaintenanceActionCommand(args);
+    };
+    RDS.prototype.applyPendingMaintenanceAction = function (args, optionsOrCb, cb) {
+        var command = new ApplyPendingMaintenanceActionCommand(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);
         }
-    }
-    authorizeDBSecurityGroupIngress(args, optionsOrCb, cb) {
-        const command = new AuthorizeDBSecurityGroupIngressCommand(args);
+    };
+    RDS.prototype.authorizeDBSecurityGroupIngress = function (args, optionsOrCb, cb) {
+        var command = new AuthorizeDBSecurityGroupIngressCommand(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);
         }
-    }
-    backtrackDBCluster(args, optionsOrCb, cb) {
-        const command = new BacktrackDBClusterCommand(args);
+    };
+    RDS.prototype.backtrackDBCluster = function (args, optionsOrCb, cb) {
+        var command = new BacktrackDBClusterCommand(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);
         }
-    }
-    cancelExportTask(args, optionsOrCb, cb) {
-        const command = new CancelExportTaskCommand(args);
+    };
+    RDS.prototype.cancelExportTask = function (args, optionsOrCb, cb) {
+        var command = new CancelExportTaskCommand(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);
         }
-    }
-    copyDBClusterParameterGroup(args, optionsOrCb, cb) {
-        const command = new CopyDBClusterParameterGroupCommand(args);
+    };
+    RDS.prototype.copyDBClusterParameterGroup = function (args, optionsOrCb, cb) {
+        var command = new CopyDBClusterParameterGroupCommand(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);
         }
-    }
-    copyDBClusterSnapshot(args, optionsOrCb, cb) {
-        const command = new CopyDBClusterSnapshotCommand(args);
+    };
+    RDS.prototype.copyDBClusterSnapshot = function (args, optionsOrCb, cb) {
+        var command = new CopyDBClusterSnapshotCommand(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);
         }
-    }
-    copyDBParameterGroup(args, optionsOrCb, cb) {
-        const command = new CopyDBParameterGroupCommand(args);
+    };
+    RDS.prototype.copyDBParameterGroup = function (args, optionsOrCb, cb) {
+        var command = new CopyDBParameterGroupCommand(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);
         }
-    }
-    copyDBSnapshot(args, optionsOrCb, cb) {
-        const command = new CopyDBSnapshotCommand(args);
+    };
+    RDS.prototype.copyDBSnapshot = function (args, optionsOrCb, cb) {
+        var command = new CopyDBSnapshotCommand(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);
         }
-    }
-    copyOptionGroup(args, optionsOrCb, cb) {
-        const command = new CopyOptionGroupCommand(args);
+    };
+    RDS.prototype.copyOptionGroup = function (args, optionsOrCb, cb) {
+        var command = new CopyOptionGroupCommand(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);
         }
-    }
-    createCustomDBEngineVersion(args, optionsOrCb, cb) {
-        const command = new CreateCustomDBEngineVersionCommand(args);
+    };
+    RDS.prototype.createCustomDBEngineVersion = function (args, optionsOrCb, cb) {
+        var command = new CreateCustomDBEngineVersionCommand(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);
         }
-    }
-    createDBCluster(args, optionsOrCb, cb) {
-        const command = new CreateDBClusterCommand(args);
+    };
+    RDS.prototype.createDBCluster = function (args, optionsOrCb, cb) {
+        var command = new CreateDBClusterCommand(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);
         }
-    }
-    createDBClusterEndpoint(args, optionsOrCb, cb) {
-        const command = new CreateDBClusterEndpointCommand(args);
+    };
+    RDS.prototype.createDBClusterEndpoint = function (args, optionsOrCb, cb) {
+        var command = new CreateDBClusterEndpointCommand(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);
         }
-    }
-    createDBClusterParameterGroup(args, optionsOrCb, cb) {
-        const command = new CreateDBClusterParameterGroupCommand(args);
+    };
+    RDS.prototype.createDBClusterParameterGroup = function (args, optionsOrCb, cb) {
+        var command = new CreateDBClusterParameterGroupCommand(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);
         }
-    }
-    createDBClusterSnapshot(args, optionsOrCb, cb) {
-        const command = new CreateDBClusterSnapshotCommand(args);
+    };
+    RDS.prototype.createDBClusterSnapshot = function (args, optionsOrCb, cb) {
+        var command = new CreateDBClusterSnapshotCommand(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);
         }
-    }
-    createDBInstance(args, optionsOrCb, cb) {
-        const command = new CreateDBInstanceCommand(args);
+    };
+    RDS.prototype.createDBInstance = function (args, optionsOrCb, cb) {
+        var command = new CreateDBInstanceCommand(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);
         }
-    }
-    createDBInstanceReadReplica(args, optionsOrCb, cb) {
-        const command = new CreateDBInstanceReadReplicaCommand(args);
+    };
+    RDS.prototype.createDBInstanceReadReplica = function (args, optionsOrCb, cb) {
+        var command = new CreateDBInstanceReadReplicaCommand(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);
         }
-    }
-    createDBParameterGroup(args, optionsOrCb, cb) {
-        const command = new CreateDBParameterGroupCommand(args);
+    };
+    RDS.prototype.createDBParameterGroup = function (args, optionsOrCb, cb) {
+        var command = new CreateDBParameterGroupCommand(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);
         }
-    }
-    createDBProxy(args, optionsOrCb, cb) {
-        const command = new CreateDBProxyCommand(args);
+    };
+    RDS.prototype.createDBProxy = function (args, optionsOrCb, cb) {
+        var command = new CreateDBProxyCommand(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);
         }
-    }
-    createDBProxyEndpoint(args, optionsOrCb, cb) {
-        const command = new CreateDBProxyEndpointCommand(args);
+    };
+    RDS.prototype.createDBProxyEndpoint = function (args, optionsOrCb, cb) {
+        var command = new CreateDBProxyEndpointCommand(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);
         }
-    }
-    createDBSecurityGroup(args, optionsOrCb, cb) {
-        const command = new CreateDBSecurityGroupCommand(args);
+    };
+    RDS.prototype.createDBSecurityGroup = function (args, optionsOrCb, cb) {
+        var command = new CreateDBSecurityGroupCommand(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);
         }
-    }
-    createDBSnapshot(args, optionsOrCb, cb) {
-        const command = new CreateDBSnapshotCommand(args);
+    };
+    RDS.prototype.createDBSnapshot = function (args, optionsOrCb, cb) {
+        var command = new CreateDBSnapshotCommand(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);
         }
-    }
-    createDBSubnetGroup(args, optionsOrCb, cb) {
-        const command = new CreateDBSubnetGroupCommand(args);
+    };
+    RDS.prototype.createDBSubnetGroup = function (args, optionsOrCb, cb) {
+        var command = new CreateDBSubnetGroupCommand(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);
         }
-    }
-    createEventSubscription(args, optionsOrCb, cb) {
-        const command = new CreateEventSubscriptionCommand(args);
+    };
+    RDS.prototype.createEventSubscription = function (args, optionsOrCb, cb) {
+        var command = new CreateEventSubscriptionCommand(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);
         }
-    }
-    createGlobalCluster(args, optionsOrCb, cb) {
-        const command = new CreateGlobalClusterCommand(args);
+    };
+    RDS.prototype.createGlobalCluster = function (args, optionsOrCb, cb) {
+        var command = new CreateGlobalClusterCommand(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);
         }
-    }
-    createOptionGroup(args, optionsOrCb, cb) {
-        const command = new CreateOptionGroupCommand(args);
+    };
+    RDS.prototype.createOptionGroup = function (args, optionsOrCb, cb) {
+        var command = new CreateOptionGroupCommand(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);
         }
-    }
-    deleteCustomDBEngineVersion(args, optionsOrCb, cb) {
-        const command = new DeleteCustomDBEngineVersionCommand(args);
+    };
+    RDS.prototype.deleteCustomDBEngineVersion = function (args, optionsOrCb, cb) {
+        var command = new DeleteCustomDBEngineVersionCommand(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);
         }
-    }
-    deleteDBCluster(args, optionsOrCb, cb) {
-        const command = new DeleteDBClusterCommand(args);
+    };
+    RDS.prototype.deleteDBCluster = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBClusterCommand(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);
         }
-    }
-    deleteDBClusterEndpoint(args, optionsOrCb, cb) {
-        const command = new DeleteDBClusterEndpointCommand(args);
+    };
+    RDS.prototype.deleteDBClusterEndpoint = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBClusterEndpointCommand(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);
         }
-    }
-    deleteDBClusterParameterGroup(args, optionsOrCb, cb) {
-        const command = new DeleteDBClusterParameterGroupCommand(args);
+    };
+    RDS.prototype.deleteDBClusterParameterGroup = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBClusterParameterGroupCommand(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);
         }
-    }
-    deleteDBClusterSnapshot(args, optionsOrCb, cb) {
-        const command = new DeleteDBClusterSnapshotCommand(args);
+    };
+    RDS.prototype.deleteDBClusterSnapshot = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBClusterSnapshotCommand(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);
         }
-    }
-    deleteDBInstance(args, optionsOrCb, cb) {
-        const command = new DeleteDBInstanceCommand(args);
+    };
+    RDS.prototype.deleteDBInstance = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBInstanceCommand(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);
         }
-    }
-    deleteDBInstanceAutomatedBackup(args, optionsOrCb, cb) {
-        const command = new DeleteDBInstanceAutomatedBackupCommand(args);
+    };
+    RDS.prototype.deleteDBInstanceAutomatedBackup = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBInstanceAutomatedBackupCommand(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);
         }
-    }
-    deleteDBParameterGroup(args, optionsOrCb, cb) {
-        const command = new DeleteDBParameterGroupCommand(args);
+    };
+    RDS.prototype.deleteDBParameterGroup = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBParameterGroupCommand(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);
         }
-    }
-    deleteDBProxy(args, optionsOrCb, cb) {
-        const command = new DeleteDBProxyCommand(args);
+    };
+    RDS.prototype.deleteDBProxy = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBProxyCommand(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);
         }
-    }
-    deleteDBProxyEndpoint(args, optionsOrCb, cb) {
-        const command = new DeleteDBProxyEndpointCommand(args);
+    };
+    RDS.prototype.deleteDBProxyEndpoint = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBProxyEndpointCommand(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);
         }
-    }
-    deleteDBSecurityGroup(args, optionsOrCb, cb) {
-        const command = new DeleteDBSecurityGroupCommand(args);
+    };
+    RDS.prototype.deleteDBSecurityGroup = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBSecurityGroupCommand(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);
         }
-    }
-    deleteDBSnapshot(args, optionsOrCb, cb) {
-        const command = new DeleteDBSnapshotCommand(args);
+    };
+    RDS.prototype.deleteDBSnapshot = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBSnapshotCommand(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);
         }
-    }
-    deleteDBSubnetGroup(args, optionsOrCb, cb) {
-        const command = new DeleteDBSubnetGroupCommand(args);
+    };
+    RDS.prototype.deleteDBSubnetGroup = function (args, optionsOrCb, cb) {
+        var command = new DeleteDBSubnetGroupCommand(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);
         }
-    }
-    deleteEventSubscription(args, optionsOrCb, cb) {
-        const command = new DeleteEventSubscriptionCommand(args);
+    };
+    RDS.prototype.deleteEventSubscription = function (args, optionsOrCb, cb) {
+        var command = new DeleteEventSubscriptionCommand(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);
         }
-    }
-    deleteGlobalCluster(args, optionsOrCb, cb) {
-        const command = new DeleteGlobalClusterCommand(args);
+    };
+    RDS.prototype.deleteGlobalCluster = function (args, optionsOrCb, cb) {
+        var command = new DeleteGlobalClusterCommand(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);
         }
-    }
-    deleteOptionGroup(args, optionsOrCb, cb) {
-        const command = new DeleteOptionGroupCommand(args);
+    };
+    RDS.prototype.deleteOptionGroup = function (args, optionsOrCb, cb) {
+        var command = new DeleteOptionGroupCommand(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);
         }
-    }
-    deregisterDBProxyTargets(args, optionsOrCb, cb) {
-        const command = new DeregisterDBProxyTargetsCommand(args);
+    };
+    RDS.prototype.deregisterDBProxyTargets = function (args, optionsOrCb, cb) {
+        var command = new DeregisterDBProxyTargetsCommand(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);
         }
-    }
-    describeAccountAttributes(args, optionsOrCb, cb) {
-        const command = new DescribeAccountAttributesCommand(args);
+    };
+    RDS.prototype.describeAccountAttributes = function (args, optionsOrCb, cb) {
+        var command = new DescribeAccountAttributesCommand(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);
         }
-    }
-    describeCertificates(args, optionsOrCb, cb) {
-        const command = new DescribeCertificatesCommand(args);
+    };
+    RDS.prototype.describeCertificates = function (args, optionsOrCb, cb) {
+        var command = new DescribeCertificatesCommand(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);
         }
-    }
-    describeDBClusterBacktracks(args, optionsOrCb, cb) {
-        const command = new DescribeDBClusterBacktracksCommand(args);
+    };
+    RDS.prototype.describeDBClusterBacktracks = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBClusterBacktracksCommand(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);
         }
-    }
-    describeDBClusterEndpoints(args, optionsOrCb, cb) {
-        const command = new DescribeDBClusterEndpointsCommand(args);
+    };
+    RDS.prototype.describeDBClusterEndpoints = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBClusterEndpointsCommand(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);
         }
-    }
-    describeDBClusterParameterGroups(args, optionsOrCb, cb) {
-        const command = new DescribeDBClusterParameterGroupsCommand(args);
+    };
+    RDS.prototype.describeDBClusterParameterGroups = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBClusterParameterGroupsCommand(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);
         }
-    }
-    describeDBClusterParameters(args, optionsOrCb, cb) {
-        const command = new DescribeDBClusterParametersCommand(args);
+    };
+    RDS.prototype.describeDBClusterParameters = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBClusterParametersCommand(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);
         }
-    }
-    describeDBClusters(args, optionsOrCb, cb) {
-        const command = new DescribeDBClustersCommand(args);
+    };
+    RDS.prototype.describeDBClusters = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBClustersCommand(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);
         }
-    }
-    describeDBClusterSnapshotAttributes(args, optionsOrCb, cb) {
-        const command = new DescribeDBClusterSnapshotAttributesCommand(args);
+    };
+    RDS.prototype.describeDBClusterSnapshotAttributes = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBClusterSnapshotAttributesCommand(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);
         }
-    }
-    describeDBClusterSnapshots(args, optionsOrCb, cb) {
-        const command = new DescribeDBClusterSnapshotsCommand(args);
+    };
+    RDS.prototype.describeDBClusterSnapshots = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBClusterSnapshotsCommand(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);
         }
-    }
-    describeDBEngineVersions(args, optionsOrCb, cb) {
-        const command = new DescribeDBEngineVersionsCommand(args);
+    };
+    RDS.prototype.describeDBEngineVersions = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBEngineVersionsCommand(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);
         }
-    }
-    describeDBInstanceAutomatedBackups(args, optionsOrCb, cb) {
-        const command = new DescribeDBInstanceAutomatedBackupsCommand(args);
+    };
+    RDS.prototype.describeDBInstanceAutomatedBackups = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBInstanceAutomatedBackupsCommand(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);
         }
-    }
-    describeDBInstances(args, optionsOrCb, cb) {
-        const command = new DescribeDBInstancesCommand(args);
+    };
+    RDS.prototype.describeDBInstances = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBInstancesCommand(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);
         }
-    }
-    describeDBLogFiles(args, optionsOrCb, cb) {
-        const command = new DescribeDBLogFilesCommand(args);
+    };
+    RDS.prototype.describeDBLogFiles = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBLogFilesCommand(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);
         }
-    }
-    describeDBParameterGroups(args, optionsOrCb, cb) {
-        const command = new DescribeDBParameterGroupsCommand(args);
+    };
+    RDS.prototype.describeDBParameterGroups = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBParameterGroupsCommand(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);
         }
-    }
-    describeDBParameters(args, optionsOrCb, cb) {
-        const command = new DescribeDBParametersCommand(args);
+    };
+    RDS.prototype.describeDBParameters = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBParametersCommand(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);
         }
-    }
-    describeDBProxies(args, optionsOrCb, cb) {
-        const command = new DescribeDBProxiesCommand(args);
+    };
+    RDS.prototype.describeDBProxies = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBProxiesCommand(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);
         }
-    }
-    describeDBProxyEndpoints(args, optionsOrCb, cb) {
-        const command = new DescribeDBProxyEndpointsCommand(args);
+    };
+    RDS.prototype.describeDBProxyEndpoints = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBProxyEndpointsCommand(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);
         }
-    }
-    describeDBProxyTargetGroups(args, optionsOrCb, cb) {
-        const command = new DescribeDBProxyTargetGroupsCommand(args);
+    };
+    RDS.prototype.describeDBProxyTargetGroups = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBProxyTargetGroupsCommand(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);
         }
-    }
-    describeDBProxyTargets(args, optionsOrCb, cb) {
-        const command = new DescribeDBProxyTargetsCommand(args);
+    };
+    RDS.prototype.describeDBProxyTargets = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBProxyTargetsCommand(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);
         }
-    }
-    describeDBSecurityGroups(args, optionsOrCb, cb) {
-        const command = new DescribeDBSecurityGroupsCommand(args);
+    };
+    RDS.prototype.describeDBSecurityGroups = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBSecurityGroupsCommand(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);
         }
-    }
-    describeDBSnapshotAttributes(args, optionsOrCb, cb) {
-        const command = new DescribeDBSnapshotAttributesCommand(args);
+    };
+    RDS.prototype.describeDBSnapshotAttributes = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBSnapshotAttributesCommand(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);
         }
-    }
-    describeDBSnapshots(args, optionsOrCb, cb) {
-        const command = new DescribeDBSnapshotsCommand(args);
+    };
+    RDS.prototype.describeDBSnapshots = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBSnapshotsCommand(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);
         }
-    }
-    describeDBSubnetGroups(args, optionsOrCb, cb) {
-        const command = new DescribeDBSubnetGroupsCommand(args);
+    };
+    RDS.prototype.describeDBSubnetGroups = function (args, optionsOrCb, cb) {
+        var command = new DescribeDBSubnetGroupsCommand(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);
         }
-    }
-    describeEngineDefaultClusterParameters(args, optionsOrCb, cb) {
-        const command = new DescribeEngineDefaultClusterParametersCommand(args);
+    };
+    RDS.prototype.describeEngineDefaultClusterParameters = function (args, optionsOrCb, cb) {
+        var command = new DescribeEngineDefaultClusterParametersCommand(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);
         }
-    }
-    describeEngineDefaultParameters(args, optionsOrCb, cb) {
-        const command = new DescribeEngineDefaultParametersCommand(args);
+    };
+    RDS.prototype.describeEngineDefaultParameters = function (args, optionsOrCb, cb) {
+        var command = new DescribeEngineDefaultParametersCommand(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);
         }
-    }
-    describeEventCategories(args, optionsOrCb, cb) {
-        const command = new DescribeEventCategoriesCommand(args);
+    };
+    RDS.prototype.describeEventCategories = function (args, optionsOrCb, cb) {
+        var command = new DescribeEventCategoriesCommand(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);
         }
-    }
-    describeEvents(args, optionsOrCb, cb) {
-        const command = new DescribeEventsCommand(args);
+    };
+    RDS.prototype.describeEvents = function (args, optionsOrCb, cb) {
+        var command = new DescribeEventsCommand(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);
         }
-    }
-    describeEventSubscriptions(args, optionsOrCb, cb) {
-        const command = new DescribeEventSubscriptionsCommand(args);
+    };
+    RDS.prototype.describeEventSubscriptions = function (args, optionsOrCb, cb) {
+        var command = new DescribeEventSubscriptionsCommand(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);
         }
-    }
-    describeExportTasks(args, optionsOrCb, cb) {
-        const command = new DescribeExportTasksCommand(args);
+    };
+    RDS.prototype.describeExportTasks = function (args, optionsOrCb, cb) {
+        var command = new DescribeExportTasksCommand(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);
         }
-    }
-    describeGlobalClusters(args, optionsOrCb, cb) {
-        const command = new DescribeGlobalClustersCommand(args);
+    };
+    RDS.prototype.describeGlobalClusters = function (args, optionsOrCb, cb) {
+        var command = new DescribeGlobalClustersCommand(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);
         }
-    }
-    describeOptionGroupOptions(args, optionsOrCb, cb) {
-        const command = new DescribeOptionGroupOptionsCommand(args);
+    };
+    RDS.prototype.describeOptionGroupOptions = function (args, optionsOrCb, cb) {
+        var command = new DescribeOptionGroupOptionsCommand(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);
         }
-    }
-    describeOptionGroups(args, optionsOrCb, cb) {
-        const command = new DescribeOptionGroupsCommand(args);
+    };
+    RDS.prototype.describeOptionGroups = function (args, optionsOrCb, cb) {
+        var command = new DescribeOptionGroupsCommand(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);
         }
-    }
-    describeOrderableDBInstanceOptions(args, optionsOrCb, cb) {
-        const command = new DescribeOrderableDBInstanceOptionsCommand(args);
+    };
+    RDS.prototype.describeOrderableDBInstanceOptions = function (args, optionsOrCb, cb) {
+        var command = new DescribeOrderableDBInstanceOptionsCommand(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);
         }
-    }
-    describePendingMaintenanceActions(args, optionsOrCb, cb) {
-        const command = new DescribePendingMaintenanceActionsCommand(args);
+    };
+    RDS.prototype.describePendingMaintenanceActions = function (args, optionsOrCb, cb) {
+        var command = new DescribePendingMaintenanceActionsCommand(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);
         }
-    }
-    describeReservedDBInstances(args, optionsOrCb, cb) {
-        const command = new DescribeReservedDBInstancesCommand(args);
+    };
+    RDS.prototype.describeReservedDBInstances = function (args, optionsOrCb, cb) {
+        var command = new DescribeReservedDBInstancesCommand(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);
         }
-    }
-    describeReservedDBInstancesOfferings(args, optionsOrCb, cb) {
-        const command = new DescribeReservedDBInstancesOfferingsCommand(args);
+    };
+    RDS.prototype.describeReservedDBInstancesOfferings = function (args, optionsOrCb, cb) {
+        var command = new DescribeReservedDBInstancesOfferingsCommand(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);
         }
-    }
-    describeSourceRegions(args, optionsOrCb, cb) {
-        const command = new DescribeSourceRegionsCommand(args);
+    };
+    RDS.prototype.describeSourceRegions = function (args, optionsOrCb, cb) {
+        var command = new DescribeSourceRegionsCommand(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);
         }
-    }
-    describeValidDBInstanceModifications(args, optionsOrCb, cb) {
-        const command = new DescribeValidDBInstanceModificationsCommand(args);
+    };
+    RDS.prototype.describeValidDBInstanceModifications = function (args, optionsOrCb, cb) {
+        var command = new DescribeValidDBInstanceModificationsCommand(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);
         }
-    }
-    downloadDBLogFilePortion(args, optionsOrCb, cb) {
-        const command = new DownloadDBLogFilePortionCommand(args);
+    };
+    RDS.prototype.downloadDBLogFilePortion = function (args, optionsOrCb, cb) {
+        var command = new DownloadDBLogFilePortionCommand(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);
         }
-    }
-    failoverDBCluster(args, optionsOrCb, cb) {
-        const command = new FailoverDBClusterCommand(args);
+    };
+    RDS.prototype.failoverDBCluster = function (args, optionsOrCb, cb) {
+        var command = new FailoverDBClusterCommand(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);
         }
-    }
-    failoverGlobalCluster(args, optionsOrCb, cb) {
-        const command = new FailoverGlobalClusterCommand(args);
+    };
+    RDS.prototype.failoverGlobalCluster = function (args, optionsOrCb, cb) {
+        var command = new FailoverGlobalClusterCommand(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);
         }
-    }
-    listTagsForResource(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourceCommand(args);
+    };
+    RDS.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
+        var command = new ListTagsForResourceCommand(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);
         }
-    }
-    modifyActivityStream(args, optionsOrCb, cb) {
-        const command = new ModifyActivityStreamCommand(args);
+    };
+    RDS.prototype.modifyActivityStream = function (args, optionsOrCb, cb) {
+        var command = new ModifyActivityStreamCommand(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);
         }
-    }
-    modifyCertificates(args, optionsOrCb, cb) {
-        const command = new ModifyCertificatesCommand(args);
+    };
+    RDS.prototype.modifyCertificates = function (args, optionsOrCb, cb) {
+        var command = new ModifyCertificatesCommand(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);
         }
-    }
-    modifyCurrentDBClusterCapacity(args, optionsOrCb, cb) {
-        const command = new ModifyCurrentDBClusterCapacityCommand(args);
+    };
+    RDS.prototype.modifyCurrentDBClusterCapacity = function (args, optionsOrCb, cb) {
+        var command = new ModifyCurrentDBClusterCapacityCommand(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);
         }
-    }
-    modifyCustomDBEngineVersion(args, optionsOrCb, cb) {
-        const command = new ModifyCustomDBEngineVersionCommand(args);
+    };
+    RDS.prototype.modifyCustomDBEngineVersion = function (args, optionsOrCb, cb) {
+        var command = new ModifyCustomDBEngineVersionCommand(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);
         }
-    }
-    modifyDBCluster(args, optionsOrCb, cb) {
-        const command = new ModifyDBClusterCommand(args);
+    };
+    RDS.prototype.modifyDBCluster = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBClusterCommand(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);
         }
-    }
-    modifyDBClusterEndpoint(args, optionsOrCb, cb) {
-        const command = new ModifyDBClusterEndpointCommand(args);
+    };
+    RDS.prototype.modifyDBClusterEndpoint = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBClusterEndpointCommand(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);
         }
-    }
-    modifyDBClusterParameterGroup(args, optionsOrCb, cb) {
-        const command = new ModifyDBClusterParameterGroupCommand(args);
+    };
+    RDS.prototype.modifyDBClusterParameterGroup = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBClusterParameterGroupCommand(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);
         }
-    }
-    modifyDBClusterSnapshotAttribute(args, optionsOrCb, cb) {
-        const command = new ModifyDBClusterSnapshotAttributeCommand(args);
+    };
+    RDS.prototype.modifyDBClusterSnapshotAttribute = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBClusterSnapshotAttributeCommand(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);
         }
-    }
-    modifyDBInstance(args, optionsOrCb, cb) {
-        const command = new ModifyDBInstanceCommand(args);
+    };
+    RDS.prototype.modifyDBInstance = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBInstanceCommand(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);
         }
-    }
-    modifyDBParameterGroup(args, optionsOrCb, cb) {
-        const command = new ModifyDBParameterGroupCommand(args);
+    };
+    RDS.prototype.modifyDBParameterGroup = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBParameterGroupCommand(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);
         }
-    }
-    modifyDBProxy(args, optionsOrCb, cb) {
-        const command = new ModifyDBProxyCommand(args);
+    };
+    RDS.prototype.modifyDBProxy = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBProxyCommand(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);
         }
-    }
-    modifyDBProxyEndpoint(args, optionsOrCb, cb) {
-        const command = new ModifyDBProxyEndpointCommand(args);
+    };
+    RDS.prototype.modifyDBProxyEndpoint = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBProxyEndpointCommand(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);
         }
-    }
-    modifyDBProxyTargetGroup(args, optionsOrCb, cb) {
-        const command = new ModifyDBProxyTargetGroupCommand(args);
+    };
+    RDS.prototype.modifyDBProxyTargetGroup = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBProxyTargetGroupCommand(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);
         }
-    }
-    modifyDBSnapshot(args, optionsOrCb, cb) {
-        const command = new ModifyDBSnapshotCommand(args);
+    };
+    RDS.prototype.modifyDBSnapshot = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBSnapshotCommand(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);
         }
-    }
-    modifyDBSnapshotAttribute(args, optionsOrCb, cb) {
-        const command = new ModifyDBSnapshotAttributeCommand(args);
+    };
+    RDS.prototype.modifyDBSnapshotAttribute = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBSnapshotAttributeCommand(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);
         }
-    }
-    modifyDBSubnetGroup(args, optionsOrCb, cb) {
-        const command = new ModifyDBSubnetGroupCommand(args);
+    };
+    RDS.prototype.modifyDBSubnetGroup = function (args, optionsOrCb, cb) {
+        var command = new ModifyDBSubnetGroupCommand(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);
         }
-    }
-    modifyEventSubscription(args, optionsOrCb, cb) {
-        const command = new ModifyEventSubscriptionCommand(args);
+    };
+    RDS.prototype.modifyEventSubscription = function (args, optionsOrCb, cb) {
+        var command = new ModifyEventSubscriptionCommand(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);
         }
-    }
-    modifyGlobalCluster(args, optionsOrCb, cb) {
-        const command = new ModifyGlobalClusterCommand(args);
+    };
+    RDS.prototype.modifyGlobalCluster = function (args, optionsOrCb, cb) {
+        var command = new ModifyGlobalClusterCommand(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);
         }
-    }
-    modifyOptionGroup(args, optionsOrCb, cb) {
-        const command = new ModifyOptionGroupCommand(args);
+    };
+    RDS.prototype.modifyOptionGroup = function (args, optionsOrCb, cb) {
+        var command = new ModifyOptionGroupCommand(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);
         }
-    }
-    promoteReadReplica(args, optionsOrCb, cb) {
-        const command = new PromoteReadReplicaCommand(args);
+    };
+    RDS.prototype.promoteReadReplica = function (args, optionsOrCb, cb) {
+        var command = new PromoteReadReplicaCommand(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);
         }
-    }
-    promoteReadReplicaDBCluster(args, optionsOrCb, cb) {
-        const command = new PromoteReadReplicaDBClusterCommand(args);
+    };
+    RDS.prototype.promoteReadReplicaDBCluster = function (args, optionsOrCb, cb) {
+        var command = new PromoteReadReplicaDBClusterCommand(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);
         }
-    }
-    purchaseReservedDBInstancesOffering(args, optionsOrCb, cb) {
-        const command = new PurchaseReservedDBInstancesOfferingCommand(args);
+    };
+    RDS.prototype.purchaseReservedDBInstancesOffering = function (args, optionsOrCb, cb) {
+        var command = new PurchaseReservedDBInstancesOfferingCommand(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);
         }
-    }
-    rebootDBCluster(args, optionsOrCb, cb) {
-        const command = new RebootDBClusterCommand(args);
+    };
+    RDS.prototype.rebootDBCluster = function (args, optionsOrCb, cb) {
+        var command = new RebootDBClusterCommand(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);
         }
-    }
-    rebootDBInstance(args, optionsOrCb, cb) {
-        const command = new RebootDBInstanceCommand(args);
+    };
+    RDS.prototype.rebootDBInstance = function (args, optionsOrCb, cb) {
+        var command = new RebootDBInstanceCommand(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);
         }
-    }
-    registerDBProxyTargets(args, optionsOrCb, cb) {
-        const command = new RegisterDBProxyTargetsCommand(args);
+    };
+    RDS.prototype.registerDBProxyTargets = function (args, optionsOrCb, cb) {
+        var command = new RegisterDBProxyTargetsCommand(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);
         }
-    }
-    removeFromGlobalCluster(args, optionsOrCb, cb) {
-        const command = new RemoveFromGlobalClusterCommand(args);
+    };
+    RDS.prototype.removeFromGlobalCluster = function (args, optionsOrCb, cb) {
+        var command = new RemoveFromGlobalClusterCommand(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);
         }
-    }
-    removeRoleFromDBCluster(args, optionsOrCb, cb) {
-        const command = new RemoveRoleFromDBClusterCommand(args);
+    };
+    RDS.prototype.removeRoleFromDBCluster = function (args, optionsOrCb, cb) {
+        var command = new RemoveRoleFromDBClusterCommand(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);
         }
-    }
-    removeRoleFromDBInstance(args, optionsOrCb, cb) {
-        const command = new RemoveRoleFromDBInstanceCommand(args);
+    };
+    RDS.prototype.removeRoleFromDBInstance = function (args, optionsOrCb, cb) {
+        var command = new RemoveRoleFromDBInstanceCommand(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);
         }
-    }
-    removeSourceIdentifierFromSubscription(args, optionsOrCb, cb) {
-        const command = new RemoveSourceIdentifierFromSubscriptionCommand(args);
+    };
+    RDS.prototype.removeSourceIdentifierFromSubscription = function (args, optionsOrCb, cb) {
+        var command = new RemoveSourceIdentifierFromSubscriptionCommand(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);
         }
-    }
-    removeTagsFromResource(args, optionsOrCb, cb) {
-        const command = new RemoveTagsFromResourceCommand(args);
+    };
+    RDS.prototype.removeTagsFromResource = function (args, optionsOrCb, cb) {
+        var command = new RemoveTagsFromResourceCommand(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);
         }
-    }
-    resetDBClusterParameterGroup(args, optionsOrCb, cb) {
-        const command = new ResetDBClusterParameterGroupCommand(args);
+    };
+    RDS.prototype.resetDBClusterParameterGroup = function (args, optionsOrCb, cb) {
+        var command = new ResetDBClusterParameterGroupCommand(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);
         }
-    }
-    resetDBParameterGroup(args, optionsOrCb, cb) {
-        const command = new ResetDBParameterGroupCommand(args);
+    };
+    RDS.prototype.resetDBParameterGroup = function (args, optionsOrCb, cb) {
+        var command = new ResetDBParameterGroupCommand(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);
         }
-    }
-    restoreDBClusterFromS3(args, optionsOrCb, cb) {
-        const command = new RestoreDBClusterFromS3Command(args);
+    };
+    RDS.prototype.restoreDBClusterFromS3 = function (args, optionsOrCb, cb) {
+        var command = new RestoreDBClusterFromS3Command(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);
         }
-    }
-    restoreDBClusterFromSnapshot(args, optionsOrCb, cb) {
-        const command = new RestoreDBClusterFromSnapshotCommand(args);
+    };
+    RDS.prototype.restoreDBClusterFromSnapshot = function (args, optionsOrCb, cb) {
+        var command = new RestoreDBClusterFromSnapshotCommand(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);
         }
-    }
-    restoreDBClusterToPointInTime(args, optionsOrCb, cb) {
-        const command = new RestoreDBClusterToPointInTimeCommand(args);
+    };
+    RDS.prototype.restoreDBClusterToPointInTime = function (args, optionsOrCb, cb) {
+        var command = new RestoreDBClusterToPointInTimeCommand(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);
         }
-    }
-    restoreDBInstanceFromDBSnapshot(args, optionsOrCb, cb) {
-        const command = new RestoreDBInstanceFromDBSnapshotCommand(args);
+    };
+    RDS.prototype.restoreDBInstanceFromDBSnapshot = function (args, optionsOrCb, cb) {
+        var command = new RestoreDBInstanceFromDBSnapshotCommand(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);
         }
-    }
-    restoreDBInstanceFromS3(args, optionsOrCb, cb) {
-        const command = new RestoreDBInstanceFromS3Command(args);
+    };
+    RDS.prototype.restoreDBInstanceFromS3 = function (args, optionsOrCb, cb) {
+        var command = new RestoreDBInstanceFromS3Command(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);
         }
-    }
-    restoreDBInstanceToPointInTime(args, optionsOrCb, cb) {
-        const command = new RestoreDBInstanceToPointInTimeCommand(args);
+    };
+    RDS.prototype.restoreDBInstanceToPointInTime = function (args, optionsOrCb, cb) {
+        var command = new RestoreDBInstanceToPointInTimeCommand(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);
         }
-    }
-    revokeDBSecurityGroupIngress(args, optionsOrCb, cb) {
-        const command = new RevokeDBSecurityGroupIngressCommand(args);
+    };
+    RDS.prototype.revokeDBSecurityGroupIngress = function (args, optionsOrCb, cb) {
+        var command = new RevokeDBSecurityGroupIngressCommand(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);
         }
-    }
-    startActivityStream(args, optionsOrCb, cb) {
-        const command = new StartActivityStreamCommand(args);
+    };
+    RDS.prototype.startActivityStream = function (args, optionsOrCb, cb) {
+        var command = new StartActivityStreamCommand(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);
         }
-    }
-    startDBCluster(args, optionsOrCb, cb) {
-        const command = new StartDBClusterCommand(args);
+    };
+    RDS.prototype.startDBCluster = function (args, optionsOrCb, cb) {
+        var command = new StartDBClusterCommand(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);
         }
-    }
-    startDBInstance(args, optionsOrCb, cb) {
-        const command = new StartDBInstanceCommand(args);
+    };
+    RDS.prototype.startDBInstance = function (args, optionsOrCb, cb) {
+        var command = new StartDBInstanceCommand(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);
         }
-    }
-    startDBInstanceAutomatedBackupsReplication(args, optionsOrCb, cb) {
-        const command = new StartDBInstanceAutomatedBackupsReplicationCommand(args);
+    };
+    RDS.prototype.startDBInstanceAutomatedBackupsReplication = function (args, optionsOrCb, cb) {
+        var command = new StartDBInstanceAutomatedBackupsReplicationCommand(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);
         }
-    }
-    startExportTask(args, optionsOrCb, cb) {
-        const command = new StartExportTaskCommand(args);
+    };
+    RDS.prototype.startExportTask = function (args, optionsOrCb, cb) {
+        var command = new StartExportTaskCommand(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);
         }
-    }
-    stopActivityStream(args, optionsOrCb, cb) {
-        const command = new StopActivityStreamCommand(args);
+    };
+    RDS.prototype.stopActivityStream = function (args, optionsOrCb, cb) {
+        var command = new StopActivityStreamCommand(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);
         }
-    }
-    stopDBCluster(args, optionsOrCb, cb) {
-        const command = new StopDBClusterCommand(args);
+    };
+    RDS.prototype.stopDBCluster = function (args, optionsOrCb, cb) {
+        var command = new StopDBClusterCommand(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);
         }
-    }
-    stopDBInstance(args, optionsOrCb, cb) {
-        const command = new StopDBInstanceCommand(args);
+    };
+    RDS.prototype.stopDBInstance = function (args, optionsOrCb, cb) {
+        var command = new StopDBInstanceCommand(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);
         }
-    }
-    stopDBInstanceAutomatedBackupsReplication(args, optionsOrCb, cb) {
-        const command = new StopDBInstanceAutomatedBackupsReplicationCommand(args);
+    };
+    RDS.prototype.stopDBInstanceAutomatedBackupsReplication = function (args, optionsOrCb, cb) {
+        var command = new StopDBInstanceAutomatedBackupsReplicationCommand(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);
         }
-    }
-    switchoverReadReplica(args, optionsOrCb, cb) {
-        const command = new SwitchoverReadReplicaCommand(args);
+    };
+    RDS.prototype.switchoverReadReplica = function (args, optionsOrCb, cb) {
+        var command = new SwitchoverReadReplicaCommand(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 RDS;
+}(RDSClient));
+export { RDS };