@aws-sdk/client-ses 3.32.0 → 3.36.0

package/dist-es/commands/SendCustomVerificationEmailCommand.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 { SendCustomVerificationEmailRequest, SendCustomVerificationEmailResponse } from "../models/models_0";
+import { deserializeAws_querySendCustomVerificationEmailCommand, serializeAws_querySendCustomVerificationEmailCommand, } from "../protocols/Aws_query";
+var SendCustomVerificationEmailCommand = (function (_super) {
+    __extends(SendCustomVerificationEmailCommand, _super);
+    function SendCustomVerificationEmailCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SendCustomVerificationEmailCommand.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 = "SESClient";
+        var commandName = "SendCustomVerificationEmailCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SendCustomVerificationEmailRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SendCustomVerificationEmailResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SendCustomVerificationEmailCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySendCustomVerificationEmailCommand(input, context);
+    };
+    SendCustomVerificationEmailCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySendCustomVerificationEmailCommand(output, context);
+    };
+    return SendCustomVerificationEmailCommand;
+}($Command));
+export { SendCustomVerificationEmailCommand };

package/dist-es/commands/SendEmailCommand.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 { SendEmailRequest, SendEmailResponse } from "../models/models_0";
+import { deserializeAws_querySendEmailCommand, serializeAws_querySendEmailCommand } from "../protocols/Aws_query";
+var SendEmailCommand = (function (_super) {
+    __extends(SendEmailCommand, _super);
+    function SendEmailCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SendEmailCommand.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 = "SESClient";
+        var commandName = "SendEmailCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SendEmailRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SendEmailResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SendEmailCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySendEmailCommand(input, context);
+    };
+    SendEmailCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySendEmailCommand(output, context);
+    };
+    return SendEmailCommand;
+}($Command));
+export { SendEmailCommand };

package/dist-es/commands/SendRawEmailCommand.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 { SendRawEmailRequest, SendRawEmailResponse } from "../models/models_0";
+import { deserializeAws_querySendRawEmailCommand, serializeAws_querySendRawEmailCommand } from "../protocols/Aws_query";
+var SendRawEmailCommand = (function (_super) {
+    __extends(SendRawEmailCommand, _super);
+    function SendRawEmailCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SendRawEmailCommand.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 = "SESClient";
+        var commandName = "SendRawEmailCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SendRawEmailRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SendRawEmailResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SendRawEmailCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySendRawEmailCommand(input, context);
+    };
+    SendRawEmailCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySendRawEmailCommand(output, context);
+    };
+    return SendRawEmailCommand;
+}($Command));
+export { SendRawEmailCommand };

package/dist-es/commands/SendTemplatedEmailCommand.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 { SendTemplatedEmailRequest, SendTemplatedEmailResponse } from "../models/models_0";
+import { deserializeAws_querySendTemplatedEmailCommand, serializeAws_querySendTemplatedEmailCommand, } from "../protocols/Aws_query";
+var SendTemplatedEmailCommand = (function (_super) {
+    __extends(SendTemplatedEmailCommand, _super);
+    function SendTemplatedEmailCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SendTemplatedEmailCommand.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 = "SESClient";
+        var commandName = "SendTemplatedEmailCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SendTemplatedEmailRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SendTemplatedEmailResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SendTemplatedEmailCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySendTemplatedEmailCommand(input, context);
+    };
+    SendTemplatedEmailCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySendTemplatedEmailCommand(output, context);
+    };
+    return SendTemplatedEmailCommand;
+}($Command));
+export { SendTemplatedEmailCommand };

package/dist-es/commands/SetActiveReceiptRuleSetCommand.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 { SetActiveReceiptRuleSetRequest, SetActiveReceiptRuleSetResponse } from "../models/models_0";
+import { deserializeAws_querySetActiveReceiptRuleSetCommand, serializeAws_querySetActiveReceiptRuleSetCommand, } from "../protocols/Aws_query";
+var SetActiveReceiptRuleSetCommand = (function (_super) {
+    __extends(SetActiveReceiptRuleSetCommand, _super);
+    function SetActiveReceiptRuleSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetActiveReceiptRuleSetCommand.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 = "SESClient";
+        var commandName = "SetActiveReceiptRuleSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetActiveReceiptRuleSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SetActiveReceiptRuleSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetActiveReceiptRuleSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetActiveReceiptRuleSetCommand(input, context);
+    };
+    SetActiveReceiptRuleSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetActiveReceiptRuleSetCommand(output, context);
+    };
+    return SetActiveReceiptRuleSetCommand;
+}($Command));
+export { SetActiveReceiptRuleSetCommand };

package/dist-es/commands/SetIdentityDkimEnabledCommand.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 { SetIdentityDkimEnabledRequest, SetIdentityDkimEnabledResponse } from "../models/models_0";
+import { deserializeAws_querySetIdentityDkimEnabledCommand, serializeAws_querySetIdentityDkimEnabledCommand, } from "../protocols/Aws_query";
+var SetIdentityDkimEnabledCommand = (function (_super) {
+    __extends(SetIdentityDkimEnabledCommand, _super);
+    function SetIdentityDkimEnabledCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetIdentityDkimEnabledCommand.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 = "SESClient";
+        var commandName = "SetIdentityDkimEnabledCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetIdentityDkimEnabledRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SetIdentityDkimEnabledResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetIdentityDkimEnabledCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetIdentityDkimEnabledCommand(input, context);
+    };
+    SetIdentityDkimEnabledCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetIdentityDkimEnabledCommand(output, context);
+    };
+    return SetIdentityDkimEnabledCommand;
+}($Command));
+export { SetIdentityDkimEnabledCommand };

package/dist-es/commands/SetIdentityFeedbackForwardingEnabledCommand.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 { SetIdentityFeedbackForwardingEnabledRequest, SetIdentityFeedbackForwardingEnabledResponse, } from "../models/models_0";
+import { deserializeAws_querySetIdentityFeedbackForwardingEnabledCommand, serializeAws_querySetIdentityFeedbackForwardingEnabledCommand, } from "../protocols/Aws_query";
+var SetIdentityFeedbackForwardingEnabledCommand = (function (_super) {
+    __extends(SetIdentityFeedbackForwardingEnabledCommand, _super);
+    function SetIdentityFeedbackForwardingEnabledCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetIdentityFeedbackForwardingEnabledCommand.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 = "SESClient";
+        var commandName = "SetIdentityFeedbackForwardingEnabledCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetIdentityFeedbackForwardingEnabledRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SetIdentityFeedbackForwardingEnabledResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetIdentityFeedbackForwardingEnabledCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetIdentityFeedbackForwardingEnabledCommand(input, context);
+    };
+    SetIdentityFeedbackForwardingEnabledCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetIdentityFeedbackForwardingEnabledCommand(output, context);
+    };
+    return SetIdentityFeedbackForwardingEnabledCommand;
+}($Command));
+export { SetIdentityFeedbackForwardingEnabledCommand };

package/dist-es/commands/SetIdentityHeadersInNotificationsEnabledCommand.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 { SetIdentityHeadersInNotificationsEnabledRequest, SetIdentityHeadersInNotificationsEnabledResponse, } from "../models/models_0";
+import { deserializeAws_querySetIdentityHeadersInNotificationsEnabledCommand, serializeAws_querySetIdentityHeadersInNotificationsEnabledCommand, } from "../protocols/Aws_query";
+var SetIdentityHeadersInNotificationsEnabledCommand = (function (_super) {
+    __extends(SetIdentityHeadersInNotificationsEnabledCommand, _super);
+    function SetIdentityHeadersInNotificationsEnabledCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetIdentityHeadersInNotificationsEnabledCommand.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 = "SESClient";
+        var commandName = "SetIdentityHeadersInNotificationsEnabledCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetIdentityHeadersInNotificationsEnabledRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SetIdentityHeadersInNotificationsEnabledResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetIdentityHeadersInNotificationsEnabledCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetIdentityHeadersInNotificationsEnabledCommand(input, context);
+    };
+    SetIdentityHeadersInNotificationsEnabledCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetIdentityHeadersInNotificationsEnabledCommand(output, context);
+    };
+    return SetIdentityHeadersInNotificationsEnabledCommand;
+}($Command));
+export { SetIdentityHeadersInNotificationsEnabledCommand };

package/dist-es/commands/SetIdentityMailFromDomainCommand.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 { SetIdentityMailFromDomainRequest, SetIdentityMailFromDomainResponse } from "../models/models_0";
+import { deserializeAws_querySetIdentityMailFromDomainCommand, serializeAws_querySetIdentityMailFromDomainCommand, } from "../protocols/Aws_query";
+var SetIdentityMailFromDomainCommand = (function (_super) {
+    __extends(SetIdentityMailFromDomainCommand, _super);
+    function SetIdentityMailFromDomainCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetIdentityMailFromDomainCommand.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 = "SESClient";
+        var commandName = "SetIdentityMailFromDomainCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetIdentityMailFromDomainRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SetIdentityMailFromDomainResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetIdentityMailFromDomainCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetIdentityMailFromDomainCommand(input, context);
+    };
+    SetIdentityMailFromDomainCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetIdentityMailFromDomainCommand(output, context);
+    };
+    return SetIdentityMailFromDomainCommand;
+}($Command));
+export { SetIdentityMailFromDomainCommand };

package/dist-es/commands/SetIdentityNotificationTopicCommand.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 { SetIdentityNotificationTopicRequest, SetIdentityNotificationTopicResponse } from "../models/models_0";
+import { deserializeAws_querySetIdentityNotificationTopicCommand, serializeAws_querySetIdentityNotificationTopicCommand, } from "../protocols/Aws_query";
+var SetIdentityNotificationTopicCommand = (function (_super) {
+    __extends(SetIdentityNotificationTopicCommand, _super);
+    function SetIdentityNotificationTopicCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetIdentityNotificationTopicCommand.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 = "SESClient";
+        var commandName = "SetIdentityNotificationTopicCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetIdentityNotificationTopicRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SetIdentityNotificationTopicResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetIdentityNotificationTopicCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetIdentityNotificationTopicCommand(input, context);
+    };
+    SetIdentityNotificationTopicCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetIdentityNotificationTopicCommand(output, context);
+    };
+    return SetIdentityNotificationTopicCommand;
+}($Command));
+export { SetIdentityNotificationTopicCommand };

package/dist-es/commands/SetReceiptRulePositionCommand.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 { SetReceiptRulePositionRequest, SetReceiptRulePositionResponse } from "../models/models_0";
+import { deserializeAws_querySetReceiptRulePositionCommand, serializeAws_querySetReceiptRulePositionCommand, } from "../protocols/Aws_query";
+var SetReceiptRulePositionCommand = (function (_super) {
+    __extends(SetReceiptRulePositionCommand, _super);
+    function SetReceiptRulePositionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SetReceiptRulePositionCommand.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 = "SESClient";
+        var commandName = "SetReceiptRulePositionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SetReceiptRulePositionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: SetReceiptRulePositionResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SetReceiptRulePositionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_querySetReceiptRulePositionCommand(input, context);
+    };
+    SetReceiptRulePositionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_querySetReceiptRulePositionCommand(output, context);
+    };
+    return SetReceiptRulePositionCommand;
+}($Command));
+export { SetReceiptRulePositionCommand };

package/dist-es/commands/TestRenderTemplateCommand.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 { TestRenderTemplateRequest, TestRenderTemplateResponse } from "../models/models_0";
+import { deserializeAws_queryTestRenderTemplateCommand, serializeAws_queryTestRenderTemplateCommand, } from "../protocols/Aws_query";
+var TestRenderTemplateCommand = (function (_super) {
+    __extends(TestRenderTemplateCommand, _super);
+    function TestRenderTemplateCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    TestRenderTemplateCommand.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 = "SESClient";
+        var commandName = "TestRenderTemplateCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: TestRenderTemplateRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: TestRenderTemplateResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    TestRenderTemplateCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryTestRenderTemplateCommand(input, context);
+    };
+    TestRenderTemplateCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryTestRenderTemplateCommand(output, context);
+    };
+    return TestRenderTemplateCommand;
+}($Command));
+export { TestRenderTemplateCommand };

package/dist-es/commands/UpdateAccountSendingEnabledCommand.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 { UpdateAccountSendingEnabledRequest } from "../models/models_0";
+import { deserializeAws_queryUpdateAccountSendingEnabledCommand, serializeAws_queryUpdateAccountSendingEnabledCommand, } from "../protocols/Aws_query";
+var UpdateAccountSendingEnabledCommand = (function (_super) {
+    __extends(UpdateAccountSendingEnabledCommand, _super);
+    function UpdateAccountSendingEnabledCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateAccountSendingEnabledCommand.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 = "SESClient";
+        var commandName = "UpdateAccountSendingEnabledCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateAccountSendingEnabledRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateAccountSendingEnabledCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryUpdateAccountSendingEnabledCommand(input, context);
+    };
+    UpdateAccountSendingEnabledCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateAccountSendingEnabledCommand(output, context);
+    };
+    return UpdateAccountSendingEnabledCommand;
+}($Command));
+export { UpdateAccountSendingEnabledCommand };

package/dist-es/commands/UpdateConfigurationSetEventDestinationCommand.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 { UpdateConfigurationSetEventDestinationRequest, UpdateConfigurationSetEventDestinationResponse, } from "../models/models_0";
+import { deserializeAws_queryUpdateConfigurationSetEventDestinationCommand, serializeAws_queryUpdateConfigurationSetEventDestinationCommand, } from "../protocols/Aws_query";
+var UpdateConfigurationSetEventDestinationCommand = (function (_super) {
+    __extends(UpdateConfigurationSetEventDestinationCommand, _super);
+    function UpdateConfigurationSetEventDestinationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateConfigurationSetEventDestinationCommand.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 = "SESClient";
+        var commandName = "UpdateConfigurationSetEventDestinationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateConfigurationSetEventDestinationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateConfigurationSetEventDestinationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateConfigurationSetEventDestinationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryUpdateConfigurationSetEventDestinationCommand(input, context);
+    };
+    UpdateConfigurationSetEventDestinationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateConfigurationSetEventDestinationCommand(output, context);
+    };
+    return UpdateConfigurationSetEventDestinationCommand;
+}($Command));
+export { UpdateConfigurationSetEventDestinationCommand };

package/dist-es/commands/UpdateConfigurationSetReputationMetricsEnabledCommand.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 { UpdateConfigurationSetReputationMetricsEnabledRequest } from "../models/models_0";
+import { deserializeAws_queryUpdateConfigurationSetReputationMetricsEnabledCommand, serializeAws_queryUpdateConfigurationSetReputationMetricsEnabledCommand, } from "../protocols/Aws_query";
+var UpdateConfigurationSetReputationMetricsEnabledCommand = (function (_super) {
+    __extends(UpdateConfigurationSetReputationMetricsEnabledCommand, _super);
+    function UpdateConfigurationSetReputationMetricsEnabledCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateConfigurationSetReputationMetricsEnabledCommand.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 = "SESClient";
+        var commandName = "UpdateConfigurationSetReputationMetricsEnabledCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateConfigurationSetReputationMetricsEnabledRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateConfigurationSetReputationMetricsEnabledCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryUpdateConfigurationSetReputationMetricsEnabledCommand(input, context);
+    };
+    UpdateConfigurationSetReputationMetricsEnabledCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateConfigurationSetReputationMetricsEnabledCommand(output, context);
+    };
+    return UpdateConfigurationSetReputationMetricsEnabledCommand;
+}($Command));
+export { UpdateConfigurationSetReputationMetricsEnabledCommand };

package/dist-es/commands/UpdateConfigurationSetSendingEnabledCommand.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 { UpdateConfigurationSetSendingEnabledRequest } from "../models/models_0";
+import { deserializeAws_queryUpdateConfigurationSetSendingEnabledCommand, serializeAws_queryUpdateConfigurationSetSendingEnabledCommand, } from "../protocols/Aws_query";
+var UpdateConfigurationSetSendingEnabledCommand = (function (_super) {
+    __extends(UpdateConfigurationSetSendingEnabledCommand, _super);
+    function UpdateConfigurationSetSendingEnabledCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateConfigurationSetSendingEnabledCommand.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 = "SESClient";
+        var commandName = "UpdateConfigurationSetSendingEnabledCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateConfigurationSetSendingEnabledRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateConfigurationSetSendingEnabledCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryUpdateConfigurationSetSendingEnabledCommand(input, context);
+    };
+    UpdateConfigurationSetSendingEnabledCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateConfigurationSetSendingEnabledCommand(output, context);
+    };
+    return UpdateConfigurationSetSendingEnabledCommand;
+}($Command));
+export { UpdateConfigurationSetSendingEnabledCommand };