@aws-sdk/client-rds 3.183.0 → 3.185.0

package/dist-es/commands/DeleteDBSecurityGroupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteDBSecurityGroupMessageFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_queryDeleteDBSecurityGroupCommand, serializeAws_queryDeleteDBSecurityGroupCommand, } from "../protocols/Aws_query";
-export class DeleteDBSecurityGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteDBSecurityGroupCommand = (function (_super) {
+    __extends(DeleteDBSecurityGroupCommand, _super);
+    function DeleteDBSecurityGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteDBSecurityGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSClient";
-        const commandName = "DeleteDBSecurityGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DeleteDBSecurityGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteDBSecurityGroupMessageFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteDBSecurityGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDeleteDBSecurityGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteDBSecurityGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDeleteDBSecurityGroupCommand(output, context);
-    }
-}
+    };
+    return DeleteDBSecurityGroupCommand;
+}($Command));
+export { DeleteDBSecurityGroupCommand };

package/dist-es/commands/DeleteDBSnapshotCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteDBSnapshotMessageFilterSensitiveLog, DeleteDBSnapshotResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDeleteDBSnapshotCommand, serializeAws_queryDeleteDBSnapshotCommand, } from "../protocols/Aws_query";
-export class DeleteDBSnapshotCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteDBSnapshotCommand = (function (_super) {
+    __extends(DeleteDBSnapshotCommand, _super);
+    function DeleteDBSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteDBSnapshotCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSClient";
-        const commandName = "DeleteDBSnapshotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DeleteDBSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteDBSnapshotMessageFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteDBSnapshotResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteDBSnapshotCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDeleteDBSnapshotCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteDBSnapshotCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDeleteDBSnapshotCommand(output, context);
-    }
-}
+    };
+    return DeleteDBSnapshotCommand;
+}($Command));
+export { DeleteDBSnapshotCommand };

package/dist-es/commands/DeleteDBSubnetGroupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteDBSubnetGroupMessageFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_queryDeleteDBSubnetGroupCommand, serializeAws_queryDeleteDBSubnetGroupCommand, } from "../protocols/Aws_query";
-export class DeleteDBSubnetGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteDBSubnetGroupCommand = (function (_super) {
+    __extends(DeleteDBSubnetGroupCommand, _super);
+    function DeleteDBSubnetGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteDBSubnetGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSClient";
-        const commandName = "DeleteDBSubnetGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DeleteDBSubnetGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteDBSubnetGroupMessageFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteDBSubnetGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDeleteDBSubnetGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteDBSubnetGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDeleteDBSubnetGroupCommand(output, context);
-    }
-}
+    };
+    return DeleteDBSubnetGroupCommand;
+}($Command));
+export { DeleteDBSubnetGroupCommand };

package/dist-es/commands/DeleteEventSubscriptionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteEventSubscriptionMessageFilterSensitiveLog, DeleteEventSubscriptionResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDeleteEventSubscriptionCommand, serializeAws_queryDeleteEventSubscriptionCommand, } from "../protocols/Aws_query";
-export class DeleteEventSubscriptionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteEventSubscriptionCommand = (function (_super) {
+    __extends(DeleteEventSubscriptionCommand, _super);
+    function DeleteEventSubscriptionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteEventSubscriptionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSClient";
-        const commandName = "DeleteEventSubscriptionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DeleteEventSubscriptionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteEventSubscriptionMessageFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteEventSubscriptionResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteEventSubscriptionCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDeleteEventSubscriptionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteEventSubscriptionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDeleteEventSubscriptionCommand(output, context);
-    }
-}
+    };
+    return DeleteEventSubscriptionCommand;
+}($Command));
+export { DeleteEventSubscriptionCommand };

package/dist-es/commands/DeleteGlobalClusterCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteGlobalClusterMessageFilterSensitiveLog, DeleteGlobalClusterResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDeleteGlobalClusterCommand, serializeAws_queryDeleteGlobalClusterCommand, } from "../protocols/Aws_query";
-export class DeleteGlobalClusterCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteGlobalClusterCommand = (function (_super) {
+    __extends(DeleteGlobalClusterCommand, _super);
+    function DeleteGlobalClusterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteGlobalClusterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSClient";
-        const commandName = "DeleteGlobalClusterCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DeleteGlobalClusterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteGlobalClusterMessageFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteGlobalClusterResultFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteGlobalClusterCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDeleteGlobalClusterCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteGlobalClusterCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDeleteGlobalClusterCommand(output, context);
-    }
-}
+    };
+    return DeleteGlobalClusterCommand;
+}($Command));
+export { DeleteGlobalClusterCommand };

package/dist-es/commands/DeleteOptionGroupCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteOptionGroupMessageFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_queryDeleteOptionGroupCommand, serializeAws_queryDeleteOptionGroupCommand, } from "../protocols/Aws_query";
-export class DeleteOptionGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteOptionGroupCommand = (function (_super) {
+    __extends(DeleteOptionGroupCommand, _super);
+    function DeleteOptionGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteOptionGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSClient";
-        const commandName = "DeleteOptionGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DeleteOptionGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteOptionGroupMessageFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteOptionGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDeleteOptionGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteOptionGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDeleteOptionGroupCommand(output, context);
-    }
-}
+    };
+    return DeleteOptionGroupCommand;
+}($Command));
+export { DeleteOptionGroupCommand };

package/dist-es/commands/DeregisterDBProxyTargetsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeregisterDBProxyTargetsRequestFilterSensitiveLog, DeregisterDBProxyTargetsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDeregisterDBProxyTargetsCommand, serializeAws_queryDeregisterDBProxyTargetsCommand, } from "../protocols/Aws_query";
-export class DeregisterDBProxyTargetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeregisterDBProxyTargetsCommand = (function (_super) {
+    __extends(DeregisterDBProxyTargetsCommand, _super);
+    function DeregisterDBProxyTargetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeregisterDBProxyTargetsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSClient";
-        const commandName = "DeregisterDBProxyTargetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DeregisterDBProxyTargetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeregisterDBProxyTargetsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeregisterDBProxyTargetsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeregisterDBProxyTargetsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDeregisterDBProxyTargetsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeregisterDBProxyTargetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDeregisterDBProxyTargetsCommand(output, context);
-    }
-}
+    };
+    return DeregisterDBProxyTargetsCommand;
+}($Command));
+export { DeregisterDBProxyTargetsCommand };

package/dist-es/commands/DescribeAccountAttributesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AccountAttributesMessageFilterSensitiveLog, DescribeAccountAttributesMessageFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDescribeAccountAttributesCommand, serializeAws_queryDescribeAccountAttributesCommand, } from "../protocols/Aws_query";
-export class DescribeAccountAttributesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeAccountAttributesCommand = (function (_super) {
+    __extends(DescribeAccountAttributesCommand, _super);
+    function DescribeAccountAttributesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeAccountAttributesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSClient";
-        const commandName = "DescribeAccountAttributesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DescribeAccountAttributesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeAccountAttributesMessageFilterSensitiveLog,
             outputFilterSensitiveLog: AccountAttributesMessageFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeAccountAttributesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDescribeAccountAttributesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeAccountAttributesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDescribeAccountAttributesCommand(output, context);
-    }
-}
+    };
+    return DescribeAccountAttributesCommand;
+}($Command));
+export { DescribeAccountAttributesCommand };

package/dist-es/commands/DescribeCertificatesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CertificateMessageFilterSensitiveLog, DescribeCertificatesMessageFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDescribeCertificatesCommand, serializeAws_queryDescribeCertificatesCommand, } from "../protocols/Aws_query";
-export class DescribeCertificatesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeCertificatesCommand = (function (_super) {
+    __extends(DescribeCertificatesCommand, _super);
+    function DescribeCertificatesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeCertificatesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSClient";
-        const commandName = "DescribeCertificatesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DescribeCertificatesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeCertificatesMessageFilterSensitiveLog,
             outputFilterSensitiveLog: CertificateMessageFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeCertificatesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDescribeCertificatesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeCertificatesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDescribeCertificatesCommand(output, context);
-    }
-}
+    };
+    return DescribeCertificatesCommand;
+}($Command));
+export { DescribeCertificatesCommand };

package/dist-es/commands/DescribeDBClusterBacktracksCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DBClusterBacktrackMessageFilterSensitiveLog, DescribeDBClusterBacktracksMessageFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryDescribeDBClusterBacktracksCommand, serializeAws_queryDescribeDBClusterBacktracksCommand, } from "../protocols/Aws_query";
-export class DescribeDBClusterBacktracksCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeDBClusterBacktracksCommand = (function (_super) {
+    __extends(DescribeDBClusterBacktracksCommand, _super);
+    function DescribeDBClusterBacktracksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeDBClusterBacktracksCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSClient";
-        const commandName = "DescribeDBClusterBacktracksCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "DescribeDBClusterBacktracksCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeDBClusterBacktracksMessageFilterSensitiveLog,
             outputFilterSensitiveLog: DBClusterBacktrackMessageFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeDBClusterBacktracksCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryDescribeDBClusterBacktracksCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeDBClusterBacktracksCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryDescribeDBClusterBacktracksCommand(output, context);
-    }
-}
+    };
+    return DescribeDBClusterBacktracksCommand;
+}($Command));
+export { DescribeDBClusterBacktracksCommand };