@aws-sdk/client-rds 3.181.0 → 3.183.0

package/dist-es/RDS.js

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