@aws-sdk/client-ses 3.183.0 → 3.185.0

package/dist-es/commands/SendRawEmailCommand.js

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

package/dist-es/commands/SendTemplatedEmailCommand.js

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

package/dist-es/commands/SetActiveReceiptRuleSetCommand.js

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

package/dist-es/commands/SetIdentityDkimEnabledCommand.js

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

package/dist-es/commands/SetIdentityFeedbackForwardingEnabledCommand.js

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

package/dist-es/commands/SetIdentityHeadersInNotificationsEnabledCommand.js

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

package/dist-es/commands/SetIdentityMailFromDomainCommand.js

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

package/dist-es/commands/SetIdentityNotificationTopicCommand.js

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

package/dist-es/commands/SetReceiptRulePositionCommand.js

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

package/dist-es/commands/TestRenderTemplateCommand.js

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