@aws-sdk/client-ses 3.186.0 → 3.190.0

package/dist-es/commands/SendRawEmailCommand.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 { SendRawEmailRequestFilterSensitiveLog, SendRawEmailResponseFilterSensitiveLog, } 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;
+export class SendRawEmailCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SendRawEmailCommand.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 = "SESClient";
-        var commandName = "SendRawEmailCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "SendRawEmailCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SendRawEmailRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SendRawEmailResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SendRawEmailCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySendRawEmailCommand(input, context);
-    };
-    SendRawEmailCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySendRawEmailCommand(output, context);
-    };
-    return SendRawEmailCommand;
-}($Command));
-export { SendRawEmailCommand };
+    }
+}

package/dist-es/commands/SendTemplatedEmailCommand.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 { SendTemplatedEmailRequestFilterSensitiveLog, SendTemplatedEmailResponseFilterSensitiveLog, } 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;
+export class SendTemplatedEmailCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SendTemplatedEmailCommand.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 = "SESClient";
-        var commandName = "SendTemplatedEmailCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "SendTemplatedEmailCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SendTemplatedEmailRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SendTemplatedEmailResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SendTemplatedEmailCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySendTemplatedEmailCommand(input, context);
-    };
-    SendTemplatedEmailCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySendTemplatedEmailCommand(output, context);
-    };
-    return SendTemplatedEmailCommand;
-}($Command));
-export { SendTemplatedEmailCommand };
+    }
+}

package/dist-es/commands/SetActiveReceiptRuleSetCommand.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 { SetActiveReceiptRuleSetRequestFilterSensitiveLog, SetActiveReceiptRuleSetResponseFilterSensitiveLog, } 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;
+export class SetActiveReceiptRuleSetCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SetActiveReceiptRuleSetCommand.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 = "SESClient";
-        var commandName = "SetActiveReceiptRuleSetCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "SetActiveReceiptRuleSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SetActiveReceiptRuleSetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SetActiveReceiptRuleSetResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SetActiveReceiptRuleSetCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySetActiveReceiptRuleSetCommand(input, context);
-    };
-    SetActiveReceiptRuleSetCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySetActiveReceiptRuleSetCommand(output, context);
-    };
-    return SetActiveReceiptRuleSetCommand;
-}($Command));
-export { SetActiveReceiptRuleSetCommand };
+    }
+}

package/dist-es/commands/SetIdentityDkimEnabledCommand.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 { SetIdentityDkimEnabledRequestFilterSensitiveLog, SetIdentityDkimEnabledResponseFilterSensitiveLog, } 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;
+export class SetIdentityDkimEnabledCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SetIdentityDkimEnabledCommand.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 = "SESClient";
-        var commandName = "SetIdentityDkimEnabledCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "SetIdentityDkimEnabledCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SetIdentityDkimEnabledRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SetIdentityDkimEnabledResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SetIdentityDkimEnabledCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySetIdentityDkimEnabledCommand(input, context);
-    };
-    SetIdentityDkimEnabledCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySetIdentityDkimEnabledCommand(output, context);
-    };
-    return SetIdentityDkimEnabledCommand;
-}($Command));
-export { SetIdentityDkimEnabledCommand };
+    }
+}

package/dist-es/commands/SetIdentityFeedbackForwardingEnabledCommand.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 { SetIdentityFeedbackForwardingEnabledRequestFilterSensitiveLog, SetIdentityFeedbackForwardingEnabledResponseFilterSensitiveLog, } 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;
+export class SetIdentityFeedbackForwardingEnabledCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SetIdentityFeedbackForwardingEnabledCommand.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 = "SESClient";
-        var commandName = "SetIdentityFeedbackForwardingEnabledCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "SetIdentityFeedbackForwardingEnabledCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SetIdentityFeedbackForwardingEnabledRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SetIdentityFeedbackForwardingEnabledResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SetIdentityFeedbackForwardingEnabledCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySetIdentityFeedbackForwardingEnabledCommand(input, context);
-    };
-    SetIdentityFeedbackForwardingEnabledCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySetIdentityFeedbackForwardingEnabledCommand(output, context);
-    };
-    return SetIdentityFeedbackForwardingEnabledCommand;
-}($Command));
-export { SetIdentityFeedbackForwardingEnabledCommand };
+    }
+}

package/dist-es/commands/SetIdentityHeadersInNotificationsEnabledCommand.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 { SetIdentityHeadersInNotificationsEnabledRequestFilterSensitiveLog, SetIdentityHeadersInNotificationsEnabledResponseFilterSensitiveLog, } 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;
+export class SetIdentityHeadersInNotificationsEnabledCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SetIdentityHeadersInNotificationsEnabledCommand.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 = "SESClient";
-        var commandName = "SetIdentityHeadersInNotificationsEnabledCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "SetIdentityHeadersInNotificationsEnabledCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SetIdentityHeadersInNotificationsEnabledRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SetIdentityHeadersInNotificationsEnabledResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SetIdentityHeadersInNotificationsEnabledCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySetIdentityHeadersInNotificationsEnabledCommand(input, context);
-    };
-    SetIdentityHeadersInNotificationsEnabledCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySetIdentityHeadersInNotificationsEnabledCommand(output, context);
-    };
-    return SetIdentityHeadersInNotificationsEnabledCommand;
-}($Command));
-export { SetIdentityHeadersInNotificationsEnabledCommand };
+    }
+}

package/dist-es/commands/SetIdentityMailFromDomainCommand.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 { SetIdentityMailFromDomainRequestFilterSensitiveLog, SetIdentityMailFromDomainResponseFilterSensitiveLog, } 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;
+export class SetIdentityMailFromDomainCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SetIdentityMailFromDomainCommand.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 = "SESClient";
-        var commandName = "SetIdentityMailFromDomainCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "SetIdentityMailFromDomainCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SetIdentityMailFromDomainRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SetIdentityMailFromDomainResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SetIdentityMailFromDomainCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySetIdentityMailFromDomainCommand(input, context);
-    };
-    SetIdentityMailFromDomainCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySetIdentityMailFromDomainCommand(output, context);
-    };
-    return SetIdentityMailFromDomainCommand;
-}($Command));
-export { SetIdentityMailFromDomainCommand };
+    }
+}

package/dist-es/commands/SetIdentityNotificationTopicCommand.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 { SetIdentityNotificationTopicRequestFilterSensitiveLog, SetIdentityNotificationTopicResponseFilterSensitiveLog, } 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;
+export class SetIdentityNotificationTopicCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SetIdentityNotificationTopicCommand.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 = "SESClient";
-        var commandName = "SetIdentityNotificationTopicCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "SetIdentityNotificationTopicCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SetIdentityNotificationTopicRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SetIdentityNotificationTopicResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SetIdentityNotificationTopicCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySetIdentityNotificationTopicCommand(input, context);
-    };
-    SetIdentityNotificationTopicCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySetIdentityNotificationTopicCommand(output, context);
-    };
-    return SetIdentityNotificationTopicCommand;
-}($Command));
-export { SetIdentityNotificationTopicCommand };
+    }
+}

package/dist-es/commands/SetReceiptRulePositionCommand.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 { SetReceiptRulePositionRequestFilterSensitiveLog, SetReceiptRulePositionResponseFilterSensitiveLog, } 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;
+export class SetReceiptRulePositionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    SetReceiptRulePositionCommand.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 = "SESClient";
-        var commandName = "SetReceiptRulePositionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "SetReceiptRulePositionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: SetReceiptRulePositionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SetReceiptRulePositionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SetReceiptRulePositionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_querySetReceiptRulePositionCommand(input, context);
-    };
-    SetReceiptRulePositionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_querySetReceiptRulePositionCommand(output, context);
-    };
-    return SetReceiptRulePositionCommand;
-}($Command));
-export { SetReceiptRulePositionCommand };
+    }
+}

package/dist-es/commands/TestRenderTemplateCommand.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 { TestRenderTemplateRequestFilterSensitiveLog, TestRenderTemplateResponseFilterSensitiveLog, } 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;
+export class TestRenderTemplateCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    TestRenderTemplateCommand.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 = "SESClient";
-        var commandName = "TestRenderTemplateCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "TestRenderTemplateCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: TestRenderTemplateRequestFilterSensitiveLog,
             outputFilterSensitiveLog: TestRenderTemplateResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    TestRenderTemplateCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_queryTestRenderTemplateCommand(input, context);
-    };
-    TestRenderTemplateCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_queryTestRenderTemplateCommand(output, context);
-    };
-    return TestRenderTemplateCommand;
-}($Command));
-export { TestRenderTemplateCommand };
+    }
+}