@aws-sdk/client-rds 3.34.0 → 3.37.0

package/dist-es/commands/CreateDBClusterEndpointCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDBClusterEndpointMessage, DBClusterEndpoint } from "../models/models_0";
+import { deserializeAws_queryCreateDBClusterEndpointCommand, serializeAws_queryCreateDBClusterEndpointCommand, } from "../protocols/Aws_query";
+var CreateDBClusterEndpointCommand = (function (_super) {
+    __extends(CreateDBClusterEndpointCommand, _super);
+    function CreateDBClusterEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDBClusterEndpointCommand.prototype.resolveMiddleware = function (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 = "CreateDBClusterEndpointCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateDBClusterEndpointMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: DBClusterEndpoint.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBClusterEndpointCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBClusterEndpointCommand(input, context);
+    };
+    CreateDBClusterEndpointCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBClusterEndpointCommand(output, context);
+    };
+    return CreateDBClusterEndpointCommand;
+}($Command));
+export { CreateDBClusterEndpointCommand };

package/dist-es/commands/CreateDBClusterParameterGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDBClusterParameterGroupMessage, CreateDBClusterParameterGroupResult } from "../models/models_0";
+import { deserializeAws_queryCreateDBClusterParameterGroupCommand, serializeAws_queryCreateDBClusterParameterGroupCommand, } from "../protocols/Aws_query";
+var CreateDBClusterParameterGroupCommand = (function (_super) {
+    __extends(CreateDBClusterParameterGroupCommand, _super);
+    function CreateDBClusterParameterGroupCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDBClusterParameterGroupCommand.prototype.resolveMiddleware = function (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 = "CreateDBClusterParameterGroupCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateDBClusterParameterGroupMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDBClusterParameterGroupResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBClusterParameterGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBClusterParameterGroupCommand(input, context);
+    };
+    CreateDBClusterParameterGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBClusterParameterGroupCommand(output, context);
+    };
+    return CreateDBClusterParameterGroupCommand;
+}($Command));
+export { CreateDBClusterParameterGroupCommand };

package/dist-es/commands/CreateDBClusterSnapshotCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDBClusterSnapshotMessage, CreateDBClusterSnapshotResult } from "../models/models_0";
+import { deserializeAws_queryCreateDBClusterSnapshotCommand, serializeAws_queryCreateDBClusterSnapshotCommand, } from "../protocols/Aws_query";
+var CreateDBClusterSnapshotCommand = (function (_super) {
+    __extends(CreateDBClusterSnapshotCommand, _super);
+    function CreateDBClusterSnapshotCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDBClusterSnapshotCommand.prototype.resolveMiddleware = function (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 = "CreateDBClusterSnapshotCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateDBClusterSnapshotMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDBClusterSnapshotResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBClusterSnapshotCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBClusterSnapshotCommand(input, context);
+    };
+    CreateDBClusterSnapshotCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBClusterSnapshotCommand(output, context);
+    };
+    return CreateDBClusterSnapshotCommand;
+}($Command));
+export { CreateDBClusterSnapshotCommand };

package/dist-es/commands/CreateDBInstanceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDBInstanceMessage, CreateDBInstanceResult } from "../models/models_0";
+import { deserializeAws_queryCreateDBInstanceCommand, serializeAws_queryCreateDBInstanceCommand, } from "../protocols/Aws_query";
+var CreateDBInstanceCommand = (function (_super) {
+    __extends(CreateDBInstanceCommand, _super);
+    function CreateDBInstanceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDBInstanceCommand.prototype.resolveMiddleware = function (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 = "CreateDBInstanceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateDBInstanceMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDBInstanceResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBInstanceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBInstanceCommand(input, context);
+    };
+    CreateDBInstanceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBInstanceCommand(output, context);
+    };
+    return CreateDBInstanceCommand;
+}($Command));
+export { CreateDBInstanceCommand };

package/dist-es/commands/CreateDBInstanceReadReplicaCommand.js

@@ -0,0 +1,41 @@
+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 { CreateDBInstanceReadReplicaMessage, CreateDBInstanceReadReplicaResult } 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;
+    }
+    CreateDBInstanceReadReplicaCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: CreateDBInstanceReadReplicaMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDBInstanceReadReplicaResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBInstanceReadReplicaCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBInstanceReadReplicaCommand(input, context);
+    };
+    CreateDBInstanceReadReplicaCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBInstanceReadReplicaCommand(output, context);
+    };
+    return CreateDBInstanceReadReplicaCommand;
+}($Command));
+export { CreateDBInstanceReadReplicaCommand };

package/dist-es/commands/CreateDBParameterGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDBParameterGroupMessage, CreateDBParameterGroupResult } 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;
+    }
+    CreateDBParameterGroupCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: CreateDBParameterGroupMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDBParameterGroupResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBParameterGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBParameterGroupCommand(input, context);
+    };
+    CreateDBParameterGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBParameterGroupCommand(output, context);
+    };
+    return CreateDBParameterGroupCommand;
+}($Command));
+export { CreateDBParameterGroupCommand };

package/dist-es/commands/CreateDBProxyCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDBProxyRequest, CreateDBProxyResponse } 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;
+    }
+    CreateDBProxyCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: CreateDBProxyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDBProxyResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBProxyCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBProxyCommand(input, context);
+    };
+    CreateDBProxyCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBProxyCommand(output, context);
+    };
+    return CreateDBProxyCommand;
+}($Command));
+export { CreateDBProxyCommand };

package/dist-es/commands/CreateDBProxyEndpointCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDBProxyEndpointRequest, CreateDBProxyEndpointResponse } 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;
+    }
+    CreateDBProxyEndpointCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: CreateDBProxyEndpointRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDBProxyEndpointResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBProxyEndpointCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBProxyEndpointCommand(input, context);
+    };
+    CreateDBProxyEndpointCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBProxyEndpointCommand(output, context);
+    };
+    return CreateDBProxyEndpointCommand;
+}($Command));
+export { CreateDBProxyEndpointCommand };

package/dist-es/commands/CreateDBSecurityGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDBSecurityGroupMessage, CreateDBSecurityGroupResult } 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;
+    }
+    CreateDBSecurityGroupCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: CreateDBSecurityGroupMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDBSecurityGroupResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBSecurityGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBSecurityGroupCommand(input, context);
+    };
+    CreateDBSecurityGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBSecurityGroupCommand(output, context);
+    };
+    return CreateDBSecurityGroupCommand;
+}($Command));
+export { CreateDBSecurityGroupCommand };

package/dist-es/commands/CreateDBSnapshotCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDBSnapshotMessage, CreateDBSnapshotResult } 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;
+    }
+    CreateDBSnapshotCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: CreateDBSnapshotMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDBSnapshotResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBSnapshotCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBSnapshotCommand(input, context);
+    };
+    CreateDBSnapshotCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBSnapshotCommand(output, context);
+    };
+    return CreateDBSnapshotCommand;
+}($Command));
+export { CreateDBSnapshotCommand };

package/dist-es/commands/CreateDBSubnetGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDBSubnetGroupMessage, CreateDBSubnetGroupResult } 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;
+    }
+    CreateDBSubnetGroupCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: CreateDBSubnetGroupMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDBSubnetGroupResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDBSubnetGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateDBSubnetGroupCommand(input, context);
+    };
+    CreateDBSubnetGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateDBSubnetGroupCommand(output, context);
+    };
+    return CreateDBSubnetGroupCommand;
+}($Command));
+export { CreateDBSubnetGroupCommand };

package/dist-es/commands/CreateEventSubscriptionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateEventSubscriptionMessage, CreateEventSubscriptionResult } 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;
+    }
+    CreateEventSubscriptionCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: CreateEventSubscriptionMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateEventSubscriptionResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateEventSubscriptionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateEventSubscriptionCommand(input, context);
+    };
+    CreateEventSubscriptionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateEventSubscriptionCommand(output, context);
+    };
+    return CreateEventSubscriptionCommand;
+}($Command));
+export { CreateEventSubscriptionCommand };

package/dist-es/commands/CreateGlobalClusterCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateGlobalClusterMessage, CreateGlobalClusterResult } 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;
+    }
+    CreateGlobalClusterCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: CreateGlobalClusterMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateGlobalClusterResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateGlobalClusterCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateGlobalClusterCommand(input, context);
+    };
+    CreateGlobalClusterCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateGlobalClusterCommand(output, context);
+    };
+    return CreateGlobalClusterCommand;
+}($Command));
+export { CreateGlobalClusterCommand };

package/dist-es/commands/CreateOptionGroupCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateOptionGroupMessage, CreateOptionGroupResult } 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;
+    }
+    CreateOptionGroupCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: CreateOptionGroupMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateOptionGroupResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateOptionGroupCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryCreateOptionGroupCommand(input, context);
+    };
+    CreateOptionGroupCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryCreateOptionGroupCommand(output, context);
+    };
+    return CreateOptionGroupCommand;
+}($Command));
+export { CreateOptionGroupCommand };

package/dist-es/commands/DeleteCustomAvailabilityZoneCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteCustomAvailabilityZoneMessage, DeleteCustomAvailabilityZoneResult } from "../models/models_0";
+import { deserializeAws_queryDeleteCustomAvailabilityZoneCommand, serializeAws_queryDeleteCustomAvailabilityZoneCommand, } from "../protocols/Aws_query";
+var DeleteCustomAvailabilityZoneCommand = (function (_super) {
+    __extends(DeleteCustomAvailabilityZoneCommand, _super);
+    function DeleteCustomAvailabilityZoneCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteCustomAvailabilityZoneCommand.prototype.resolveMiddleware = function (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 = "DeleteCustomAvailabilityZoneCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteCustomAvailabilityZoneMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteCustomAvailabilityZoneResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteCustomAvailabilityZoneCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryDeleteCustomAvailabilityZoneCommand(input, context);
+    };
+    DeleteCustomAvailabilityZoneCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryDeleteCustomAvailabilityZoneCommand(output, context);
+    };
+    return DeleteCustomAvailabilityZoneCommand;
+}($Command));
+export { DeleteCustomAvailabilityZoneCommand };

package/dist-es/commands/DeleteDBClusterCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteDBClusterMessage, DeleteDBClusterResult } from "../models/models_0";
+import { deserializeAws_queryDeleteDBClusterCommand, serializeAws_queryDeleteDBClusterCommand, } from "../protocols/Aws_query";
+var DeleteDBClusterCommand = (function (_super) {
+    __extends(DeleteDBClusterCommand, _super);
+    function DeleteDBClusterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteDBClusterCommand.prototype.resolveMiddleware = function (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 = "DeleteDBClusterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteDBClusterMessage.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteDBClusterResult.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteDBClusterCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryDeleteDBClusterCommand(input, context);
+    };
+    DeleteDBClusterCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryDeleteDBClusterCommand(output, context);
+    };
+    return DeleteDBClusterCommand;
+}($Command));
+export { DeleteDBClusterCommand };