@aws-sdk/client-rds 3.183.0 → 3.185.0

package/dist-es/commands/ModifyDBProxyEndpointCommand.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 { ModifyDBProxyEndpointRequestFilterSensitiveLog, ModifyDBProxyEndpointResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryModifyDBProxyEndpointCommand, serializeAws_queryModifyDBProxyEndpointCommand, } from "../protocols/Aws_query";
-export class ModifyDBProxyEndpointCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyDBProxyEndpointCommand = (function (_super) {
+    __extends(ModifyDBProxyEndpointCommand, _super);
+    function ModifyDBProxyEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyDBProxyEndpointCommand.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 = "ModifyDBProxyEndpointCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "ModifyDBProxyEndpointCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyDBProxyEndpointRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyDBProxyEndpointResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyDBProxyEndpointCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyDBProxyEndpointCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyDBProxyEndpointCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyDBProxyEndpointCommand(output, context);
-    }
-}
+    };
+    return ModifyDBProxyEndpointCommand;
+}($Command));
+export { ModifyDBProxyEndpointCommand };

package/dist-es/commands/ModifyDBProxyTargetGroupCommand.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 { ModifyDBProxyTargetGroupRequestFilterSensitiveLog, ModifyDBProxyTargetGroupResponseFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryModifyDBProxyTargetGroupCommand, serializeAws_queryModifyDBProxyTargetGroupCommand, } from "../protocols/Aws_query";
-export class ModifyDBProxyTargetGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyDBProxyTargetGroupCommand = (function (_super) {
+    __extends(ModifyDBProxyTargetGroupCommand, _super);
+    function ModifyDBProxyTargetGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyDBProxyTargetGroupCommand.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 = "ModifyDBProxyTargetGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "ModifyDBProxyTargetGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyDBProxyTargetGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyDBProxyTargetGroupResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyDBProxyTargetGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyDBProxyTargetGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyDBProxyTargetGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyDBProxyTargetGroupCommand(output, context);
-    }
-}
+    };
+    return ModifyDBProxyTargetGroupCommand;
+}($Command));
+export { ModifyDBProxyTargetGroupCommand };

package/dist-es/commands/ModifyDBSnapshotAttributeCommand.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 { ModifyDBSnapshotAttributeMessageFilterSensitiveLog, ModifyDBSnapshotAttributeResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryModifyDBSnapshotAttributeCommand, serializeAws_queryModifyDBSnapshotAttributeCommand, } from "../protocols/Aws_query";
-export class ModifyDBSnapshotAttributeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyDBSnapshotAttributeCommand = (function (_super) {
+    __extends(ModifyDBSnapshotAttributeCommand, _super);
+    function ModifyDBSnapshotAttributeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyDBSnapshotAttributeCommand.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 = "ModifyDBSnapshotAttributeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "ModifyDBSnapshotAttributeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyDBSnapshotAttributeMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyDBSnapshotAttributeResultFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyDBSnapshotAttributeCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyDBSnapshotAttributeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyDBSnapshotAttributeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyDBSnapshotAttributeCommand(output, context);
-    }
-}
+    };
+    return ModifyDBSnapshotAttributeCommand;
+}($Command));
+export { ModifyDBSnapshotAttributeCommand };

package/dist-es/commands/ModifyDBSnapshotCommand.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 { ModifyDBSnapshotMessageFilterSensitiveLog, ModifyDBSnapshotResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryModifyDBSnapshotCommand, serializeAws_queryModifyDBSnapshotCommand, } from "../protocols/Aws_query";
-export class ModifyDBSnapshotCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyDBSnapshotCommand = (function (_super) {
+    __extends(ModifyDBSnapshotCommand, _super);
+    function ModifyDBSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyDBSnapshotCommand.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 = "ModifyDBSnapshotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "ModifyDBSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyDBSnapshotMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyDBSnapshotResultFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyDBSnapshotCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyDBSnapshotCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyDBSnapshotCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyDBSnapshotCommand(output, context);
-    }
-}
+    };
+    return ModifyDBSnapshotCommand;
+}($Command));
+export { ModifyDBSnapshotCommand };

package/dist-es/commands/ModifyDBSubnetGroupCommand.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 { ModifyDBSubnetGroupMessageFilterSensitiveLog, ModifyDBSubnetGroupResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryModifyDBSubnetGroupCommand, serializeAws_queryModifyDBSubnetGroupCommand, } from "../protocols/Aws_query";
-export class ModifyDBSubnetGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyDBSubnetGroupCommand = (function (_super) {
+    __extends(ModifyDBSubnetGroupCommand, _super);
+    function ModifyDBSubnetGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyDBSubnetGroupCommand.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 = "ModifyDBSubnetGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "ModifyDBSubnetGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyDBSubnetGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyDBSubnetGroupResultFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyDBSubnetGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyDBSubnetGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyDBSubnetGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyDBSubnetGroupCommand(output, context);
-    }
-}
+    };
+    return ModifyDBSubnetGroupCommand;
+}($Command));
+export { ModifyDBSubnetGroupCommand };

package/dist-es/commands/ModifyEventSubscriptionCommand.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 { ModifyEventSubscriptionMessageFilterSensitiveLog, ModifyEventSubscriptionResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryModifyEventSubscriptionCommand, serializeAws_queryModifyEventSubscriptionCommand, } from "../protocols/Aws_query";
-export class ModifyEventSubscriptionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyEventSubscriptionCommand = (function (_super) {
+    __extends(ModifyEventSubscriptionCommand, _super);
+    function ModifyEventSubscriptionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyEventSubscriptionCommand.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 = "ModifyEventSubscriptionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "ModifyEventSubscriptionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyEventSubscriptionMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyEventSubscriptionResultFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyEventSubscriptionCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyEventSubscriptionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyEventSubscriptionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyEventSubscriptionCommand(output, context);
-    }
-}
+    };
+    return ModifyEventSubscriptionCommand;
+}($Command));
+export { ModifyEventSubscriptionCommand };

package/dist-es/commands/ModifyGlobalClusterCommand.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 { ModifyGlobalClusterMessageFilterSensitiveLog, ModifyGlobalClusterResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryModifyGlobalClusterCommand, serializeAws_queryModifyGlobalClusterCommand, } from "../protocols/Aws_query";
-export class ModifyGlobalClusterCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyGlobalClusterCommand = (function (_super) {
+    __extends(ModifyGlobalClusterCommand, _super);
+    function ModifyGlobalClusterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyGlobalClusterCommand.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 = "ModifyGlobalClusterCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "ModifyGlobalClusterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyGlobalClusterMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyGlobalClusterResultFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyGlobalClusterCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyGlobalClusterCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyGlobalClusterCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyGlobalClusterCommand(output, context);
-    }
-}
+    };
+    return ModifyGlobalClusterCommand;
+}($Command));
+export { ModifyGlobalClusterCommand };

package/dist-es/commands/ModifyOptionGroupCommand.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 { ModifyOptionGroupMessageFilterSensitiveLog, ModifyOptionGroupResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryModifyOptionGroupCommand, serializeAws_queryModifyOptionGroupCommand, } from "../protocols/Aws_query";
-export class ModifyOptionGroupCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ModifyOptionGroupCommand = (function (_super) {
+    __extends(ModifyOptionGroupCommand, _super);
+    function ModifyOptionGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ModifyOptionGroupCommand.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 = "ModifyOptionGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "ModifyOptionGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ModifyOptionGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyOptionGroupResultFilterSensitiveLog,
         };
-        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);
+    };
+    ModifyOptionGroupCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryModifyOptionGroupCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ModifyOptionGroupCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryModifyOptionGroupCommand(output, context);
-    }
-}
+    };
+    return ModifyOptionGroupCommand;
+}($Command));
+export { ModifyOptionGroupCommand };

package/dist-es/commands/PromoteReadReplicaCommand.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 { PromoteReadReplicaMessageFilterSensitiveLog, PromoteReadReplicaResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryPromoteReadReplicaCommand, serializeAws_queryPromoteReadReplicaCommand, } from "../protocols/Aws_query";
-export class PromoteReadReplicaCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PromoteReadReplicaCommand = (function (_super) {
+    __extends(PromoteReadReplicaCommand, _super);
+    function PromoteReadReplicaCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PromoteReadReplicaCommand.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 = "PromoteReadReplicaCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "PromoteReadReplicaCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PromoteReadReplicaMessageFilterSensitiveLog,
             outputFilterSensitiveLog: PromoteReadReplicaResultFilterSensitiveLog,
         };
-        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);
+    };
+    PromoteReadReplicaCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryPromoteReadReplicaCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PromoteReadReplicaCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryPromoteReadReplicaCommand(output, context);
-    }
-}
+    };
+    return PromoteReadReplicaCommand;
+}($Command));
+export { PromoteReadReplicaCommand };

package/dist-es/commands/PromoteReadReplicaDBClusterCommand.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 { PromoteReadReplicaDBClusterMessageFilterSensitiveLog, PromoteReadReplicaDBClusterResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_queryPromoteReadReplicaDBClusterCommand, serializeAws_queryPromoteReadReplicaDBClusterCommand, } from "../protocols/Aws_query";
-export class PromoteReadReplicaDBClusterCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PromoteReadReplicaDBClusterCommand = (function (_super) {
+    __extends(PromoteReadReplicaDBClusterCommand, _super);
+    function PromoteReadReplicaDBClusterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PromoteReadReplicaDBClusterCommand.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 = "PromoteReadReplicaDBClusterCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "RDSClient";
+        var commandName = "PromoteReadReplicaDBClusterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PromoteReadReplicaDBClusterMessageFilterSensitiveLog,
             outputFilterSensitiveLog: PromoteReadReplicaDBClusterResultFilterSensitiveLog,
         };
-        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);
+    };
+    PromoteReadReplicaDBClusterCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryPromoteReadReplicaDBClusterCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PromoteReadReplicaDBClusterCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryPromoteReadReplicaDBClusterCommand(output, context);
-    }
-}
+    };
+    return PromoteReadReplicaDBClusterCommand;
+}($Command));
+export { PromoteReadReplicaDBClusterCommand };