@aws-sdk/client-rds 3.185.0 → 3.188.0

package/dist-es/commands/CreateDBInstanceReadReplicaCommand.js

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

package/dist-es/commands/CreateDBParameterGroupCommand.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 { CreateDBParameterGroupMessageFilterSensitiveLog, CreateDBParameterGroupResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateDBParameterGroupCommand, serializeAws_queryCreateDBParameterGroupCommand, } from "../protocols/Aws_query";
-var CreateDBParameterGroupCommand = (function (_super) {
-    __extends(CreateDBParameterGroupCommand, _super);
-    function CreateDBParameterGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateDBParameterGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateDBParameterGroupCommand.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 = "CreateDBParameterGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "CreateDBParameterGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateDBParameterGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDBParameterGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateDBParameterGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryCreateDBParameterGroupCommand(input, context);
-    };
-    CreateDBParameterGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryCreateDBParameterGroupCommand(output, context);
-    };
-    return CreateDBParameterGroupCommand;
-}($Command));
-export { CreateDBParameterGroupCommand };
+    }
+}

package/dist-es/commands/CreateDBProxyCommand.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 { CreateDBProxyRequestFilterSensitiveLog, CreateDBProxyResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateDBProxyCommand, serializeAws_queryCreateDBProxyCommand, } from "../protocols/Aws_query";
-var CreateDBProxyCommand = (function (_super) {
-    __extends(CreateDBProxyCommand, _super);
-    function CreateDBProxyCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateDBProxyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateDBProxyCommand.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 = "CreateDBProxyCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "CreateDBProxyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateDBProxyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDBProxyResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateDBProxyCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryCreateDBProxyCommand(input, context);
-    };
-    CreateDBProxyCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryCreateDBProxyCommand(output, context);
-    };
-    return CreateDBProxyCommand;
-}($Command));
-export { CreateDBProxyCommand };
+    }
+}

package/dist-es/commands/CreateDBProxyEndpointCommand.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 { CreateDBProxyEndpointRequestFilterSensitiveLog, CreateDBProxyEndpointResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateDBProxyEndpointCommand, serializeAws_queryCreateDBProxyEndpointCommand, } from "../protocols/Aws_query";
-var CreateDBProxyEndpointCommand = (function (_super) {
-    __extends(CreateDBProxyEndpointCommand, _super);
-    function CreateDBProxyEndpointCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateDBProxyEndpointCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateDBProxyEndpointCommand.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 = "CreateDBProxyEndpointCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "CreateDBProxyEndpointCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateDBProxyEndpointRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDBProxyEndpointResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateDBProxyEndpointCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryCreateDBProxyEndpointCommand(input, context);
-    };
-    CreateDBProxyEndpointCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryCreateDBProxyEndpointCommand(output, context);
-    };
-    return CreateDBProxyEndpointCommand;
-}($Command));
-export { CreateDBProxyEndpointCommand };
+    }
+}

package/dist-es/commands/CreateDBSecurityGroupCommand.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 { CreateDBSecurityGroupMessageFilterSensitiveLog, CreateDBSecurityGroupResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateDBSecurityGroupCommand, serializeAws_queryCreateDBSecurityGroupCommand, } from "../protocols/Aws_query";
-var CreateDBSecurityGroupCommand = (function (_super) {
-    __extends(CreateDBSecurityGroupCommand, _super);
-    function CreateDBSecurityGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateDBSecurityGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateDBSecurityGroupCommand.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 = "CreateDBSecurityGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "CreateDBSecurityGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateDBSecurityGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDBSecurityGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateDBSecurityGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryCreateDBSecurityGroupCommand(input, context);
-    };
-    CreateDBSecurityGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryCreateDBSecurityGroupCommand(output, context);
-    };
-    return CreateDBSecurityGroupCommand;
-}($Command));
-export { CreateDBSecurityGroupCommand };
+    }
+}

package/dist-es/commands/CreateDBSnapshotCommand.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 { CreateDBSnapshotMessageFilterSensitiveLog, CreateDBSnapshotResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateDBSnapshotCommand, serializeAws_queryCreateDBSnapshotCommand, } from "../protocols/Aws_query";
-var CreateDBSnapshotCommand = (function (_super) {
-    __extends(CreateDBSnapshotCommand, _super);
-    function CreateDBSnapshotCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateDBSnapshotCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateDBSnapshotCommand.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 = "CreateDBSnapshotCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "CreateDBSnapshotCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateDBSnapshotMessageFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDBSnapshotResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateDBSnapshotCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryCreateDBSnapshotCommand(input, context);
-    };
-    CreateDBSnapshotCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryCreateDBSnapshotCommand(output, context);
-    };
-    return CreateDBSnapshotCommand;
-}($Command));
-export { CreateDBSnapshotCommand };
+    }
+}

package/dist-es/commands/CreateDBSubnetGroupCommand.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 { CreateDBSubnetGroupMessageFilterSensitiveLog, CreateDBSubnetGroupResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateDBSubnetGroupCommand, serializeAws_queryCreateDBSubnetGroupCommand, } from "../protocols/Aws_query";
-var CreateDBSubnetGroupCommand = (function (_super) {
-    __extends(CreateDBSubnetGroupCommand, _super);
-    function CreateDBSubnetGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateDBSubnetGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateDBSubnetGroupCommand.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 = "CreateDBSubnetGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "CreateDBSubnetGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateDBSubnetGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDBSubnetGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateDBSubnetGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryCreateDBSubnetGroupCommand(input, context);
-    };
-    CreateDBSubnetGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryCreateDBSubnetGroupCommand(output, context);
-    };
-    return CreateDBSubnetGroupCommand;
-}($Command));
-export { CreateDBSubnetGroupCommand };
+    }
+}

package/dist-es/commands/CreateEventSubscriptionCommand.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 { CreateEventSubscriptionMessageFilterSensitiveLog, CreateEventSubscriptionResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateEventSubscriptionCommand, serializeAws_queryCreateEventSubscriptionCommand, } from "../protocols/Aws_query";
-var CreateEventSubscriptionCommand = (function (_super) {
-    __extends(CreateEventSubscriptionCommand, _super);
-    function CreateEventSubscriptionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateEventSubscriptionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateEventSubscriptionCommand.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 = "CreateEventSubscriptionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "CreateEventSubscriptionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateEventSubscriptionMessageFilterSensitiveLog,
             outputFilterSensitiveLog: CreateEventSubscriptionResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateEventSubscriptionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryCreateEventSubscriptionCommand(input, context);
-    };
-    CreateEventSubscriptionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryCreateEventSubscriptionCommand(output, context);
-    };
-    return CreateEventSubscriptionCommand;
-}($Command));
-export { CreateEventSubscriptionCommand };
+    }
+}

package/dist-es/commands/CreateGlobalClusterCommand.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 { CreateGlobalClusterMessageFilterSensitiveLog, CreateGlobalClusterResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateGlobalClusterCommand, serializeAws_queryCreateGlobalClusterCommand, } from "../protocols/Aws_query";
-var CreateGlobalClusterCommand = (function (_super) {
-    __extends(CreateGlobalClusterCommand, _super);
-    function CreateGlobalClusterCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateGlobalClusterCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateGlobalClusterCommand.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 = "CreateGlobalClusterCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "CreateGlobalClusterCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateGlobalClusterMessageFilterSensitiveLog,
             outputFilterSensitiveLog: CreateGlobalClusterResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateGlobalClusterCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryCreateGlobalClusterCommand(input, context);
-    };
-    CreateGlobalClusterCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryCreateGlobalClusterCommand(output, context);
-    };
-    return CreateGlobalClusterCommand;
-}($Command));
-export { CreateGlobalClusterCommand };
+    }
+}

package/dist-es/commands/CreateOptionGroupCommand.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 { CreateOptionGroupMessageFilterSensitiveLog, CreateOptionGroupResultFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryCreateOptionGroupCommand, serializeAws_queryCreateOptionGroupCommand, } from "../protocols/Aws_query";
-var CreateOptionGroupCommand = (function (_super) {
-    __extends(CreateOptionGroupCommand, _super);
-    function CreateOptionGroupCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class CreateOptionGroupCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    CreateOptionGroupCommand.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 = "CreateOptionGroupCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RDSClient";
+        const commandName = "CreateOptionGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: CreateOptionGroupMessageFilterSensitiveLog,
             outputFilterSensitiveLog: CreateOptionGroupResultFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    CreateOptionGroupCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryCreateOptionGroupCommand(input, context);
-    };
-    CreateOptionGroupCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryCreateOptionGroupCommand(output, context);
-    };
-    return CreateOptionGroupCommand;
-}($Command));
-export { CreateOptionGroupCommand };
+    }
+}