@aws-sdk/client-rds 3.185.0 → 3.188.0

package/dist-es/commands/ModifyDBProxyEndpointCommand.js

@@ -1,39 +1,32 @@
-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";
-var ModifyDBProxyEndpointCommand = (function (_super) {
-    __extends(ModifyDBProxyEndpointCommand, _super);
-    function ModifyDBProxyEndpointCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyDBProxyEndpointCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyDBProxyEndpointCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "RDSClient";
-        var commandName = "ModifyDBProxyEndpointCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "ModifyDBProxyEndpointCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyDBProxyEndpointRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyDBProxyEndpointResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyDBProxyEndpointCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyDBProxyEndpointCommand(input, context);
-    };
-    ModifyDBProxyEndpointCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyDBProxyEndpointCommand(output, context);
-    };
-    return ModifyDBProxyEndpointCommand;
-}($Command));
-export { ModifyDBProxyEndpointCommand };
+    }
+}

package/dist-es/commands/ModifyDBProxyTargetGroupCommand.js

@@ -1,39 +1,32 @@
-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";
-var ModifyDBProxyTargetGroupCommand = (function (_super) {
-    __extends(ModifyDBProxyTargetGroupCommand, _super);
-    function ModifyDBProxyTargetGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyDBProxyTargetGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyDBProxyTargetGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "RDSClient";
-        var commandName = "ModifyDBProxyTargetGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "ModifyDBProxyTargetGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyDBProxyTargetGroupRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyDBProxyTargetGroupResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyDBProxyTargetGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyDBProxyTargetGroupCommand(input, context);
-    };
-    ModifyDBProxyTargetGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyDBProxyTargetGroupCommand(output, context);
-    };
-    return ModifyDBProxyTargetGroupCommand;
-}($Command));
-export { ModifyDBProxyTargetGroupCommand };
+    }
+}

package/dist-es/commands/ModifyDBSnapshotAttributeCommand.js

@@ -1,39 +1,32 @@
-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";
-var ModifyDBSnapshotAttributeCommand = (function (_super) {
-    __extends(ModifyDBSnapshotAttributeCommand, _super);
-    function ModifyDBSnapshotAttributeCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyDBSnapshotAttributeCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyDBSnapshotAttributeCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "RDSClient";
-        var commandName = "ModifyDBSnapshotAttributeCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "ModifyDBSnapshotAttributeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyDBSnapshotAttributeMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyDBSnapshotAttributeResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyDBSnapshotAttributeCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyDBSnapshotAttributeCommand(input, context);
-    };
-    ModifyDBSnapshotAttributeCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyDBSnapshotAttributeCommand(output, context);
-    };
-    return ModifyDBSnapshotAttributeCommand;
-}($Command));
-export { ModifyDBSnapshotAttributeCommand };
+    }
+}

package/dist-es/commands/ModifyDBSnapshotCommand.js

@@ -1,39 +1,32 @@
-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";
-var ModifyDBSnapshotCommand = (function (_super) {
-    __extends(ModifyDBSnapshotCommand, _super);
-    function ModifyDBSnapshotCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyDBSnapshotCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyDBSnapshotCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "RDSClient";
-        var commandName = "ModifyDBSnapshotCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "ModifyDBSnapshotCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyDBSnapshotMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyDBSnapshotResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyDBSnapshotCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyDBSnapshotCommand(input, context);
-    };
-    ModifyDBSnapshotCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyDBSnapshotCommand(output, context);
-    };
-    return ModifyDBSnapshotCommand;
-}($Command));
-export { ModifyDBSnapshotCommand };
+    }
+}

package/dist-es/commands/ModifyDBSubnetGroupCommand.js

@@ -1,39 +1,32 @@
-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";
-var ModifyDBSubnetGroupCommand = (function (_super) {
-    __extends(ModifyDBSubnetGroupCommand, _super);
-    function ModifyDBSubnetGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyDBSubnetGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyDBSubnetGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "RDSClient";
-        var commandName = "ModifyDBSubnetGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "ModifyDBSubnetGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyDBSubnetGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyDBSubnetGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyDBSubnetGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyDBSubnetGroupCommand(input, context);
-    };
-    ModifyDBSubnetGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyDBSubnetGroupCommand(output, context);
-    };
-    return ModifyDBSubnetGroupCommand;
-}($Command));
-export { ModifyDBSubnetGroupCommand };
+    }
+}

package/dist-es/commands/ModifyEventSubscriptionCommand.js

@@ -1,39 +1,32 @@
-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";
-var ModifyEventSubscriptionCommand = (function (_super) {
-    __extends(ModifyEventSubscriptionCommand, _super);
-    function ModifyEventSubscriptionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyEventSubscriptionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyEventSubscriptionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "RDSClient";
-        var commandName = "ModifyEventSubscriptionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "ModifyEventSubscriptionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyEventSubscriptionMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyEventSubscriptionResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyEventSubscriptionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyEventSubscriptionCommand(input, context);
-    };
-    ModifyEventSubscriptionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyEventSubscriptionCommand(output, context);
-    };
-    return ModifyEventSubscriptionCommand;
-}($Command));
-export { ModifyEventSubscriptionCommand };
+    }
+}

package/dist-es/commands/ModifyGlobalClusterCommand.js

@@ -1,39 +1,32 @@
-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";
-var ModifyGlobalClusterCommand = (function (_super) {
-    __extends(ModifyGlobalClusterCommand, _super);
-    function ModifyGlobalClusterCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyGlobalClusterCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyGlobalClusterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "RDSClient";
-        var commandName = "ModifyGlobalClusterCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "ModifyGlobalClusterCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyGlobalClusterMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyGlobalClusterResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyGlobalClusterCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyGlobalClusterCommand(input, context);
-    };
-    ModifyGlobalClusterCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyGlobalClusterCommand(output, context);
-    };
-    return ModifyGlobalClusterCommand;
-}($Command));
-export { ModifyGlobalClusterCommand };
+    }
+}

package/dist-es/commands/ModifyOptionGroupCommand.js

@@ -1,39 +1,32 @@
-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";
-var ModifyOptionGroupCommand = (function (_super) {
-    __extends(ModifyOptionGroupCommand, _super);
-    function ModifyOptionGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class ModifyOptionGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    ModifyOptionGroupCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "RDSClient";
-        var commandName = "ModifyOptionGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "ModifyOptionGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: ModifyOptionGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: ModifyOptionGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    ModifyOptionGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryModifyOptionGroupCommand(input, context);
-    };
-    ModifyOptionGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryModifyOptionGroupCommand(output, context);
-    };
-    return ModifyOptionGroupCommand;
-}($Command));
-export { ModifyOptionGroupCommand };
+    }
+}

package/dist-es/commands/PromoteReadReplicaCommand.js

@@ -1,39 +1,32 @@
-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";
-var PromoteReadReplicaCommand = (function (_super) {
-    __extends(PromoteReadReplicaCommand, _super);
-    function PromoteReadReplicaCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class PromoteReadReplicaCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    PromoteReadReplicaCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "RDSClient";
-        var commandName = "PromoteReadReplicaCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "PromoteReadReplicaCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: PromoteReadReplicaMessageFilterSensitiveLog,
             outputFilterSensitiveLog: PromoteReadReplicaResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    PromoteReadReplicaCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryPromoteReadReplicaCommand(input, context);
-    };
-    PromoteReadReplicaCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryPromoteReadReplicaCommand(output, context);
-    };
-    return PromoteReadReplicaCommand;
-}($Command));
-export { PromoteReadReplicaCommand };
+    }
+}

package/dist-es/commands/PromoteReadReplicaDBClusterCommand.js

@@ -1,39 +1,32 @@
-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";
-var PromoteReadReplicaDBClusterCommand = (function (_super) {
-    __extends(PromoteReadReplicaDBClusterCommand, _super);
-    function PromoteReadReplicaDBClusterCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class PromoteReadReplicaDBClusterCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    PromoteReadReplicaDBClusterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "RDSClient";
-        var commandName = "PromoteReadReplicaDBClusterCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "PromoteReadReplicaDBClusterCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: PromoteReadReplicaDBClusterMessageFilterSensitiveLog,
             outputFilterSensitiveLog: PromoteReadReplicaDBClusterResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    PromoteReadReplicaDBClusterCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryPromoteReadReplicaDBClusterCommand(input, context);
-    };
-    PromoteReadReplicaDBClusterCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryPromoteReadReplicaDBClusterCommand(output, context);
-    };
-    return PromoteReadReplicaDBClusterCommand;
-}($Command));
-export { PromoteReadReplicaDBClusterCommand };
+    }
+}