@aws-sdk/client-ses 3.183.0 → 3.185.0

package/dist-es/commands/ListReceiptRuleSetsCommand.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 { ListReceiptRuleSetsRequestFilterSensitiveLog, ListReceiptRuleSetsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListReceiptRuleSetsCommand, serializeAws_queryListReceiptRuleSetsCommand, } from "../protocols/Aws_query";
-export class ListReceiptRuleSetsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListReceiptRuleSetsCommand = (function (_super) {
+    __extends(ListReceiptRuleSetsCommand, _super);
+    function ListReceiptRuleSetsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListReceiptRuleSetsCommand.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 = "ListReceiptRuleSetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "ListReceiptRuleSetsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListReceiptRuleSetsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListReceiptRuleSetsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListReceiptRuleSetsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListReceiptRuleSetsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListReceiptRuleSetsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListReceiptRuleSetsCommand(output, context);
-    }
-}
+    };
+    return ListReceiptRuleSetsCommand;
+}($Command));
+export { ListReceiptRuleSetsCommand };

package/dist-es/commands/ListTemplatesCommand.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 { ListTemplatesRequestFilterSensitiveLog, ListTemplatesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryListTemplatesCommand, serializeAws_queryListTemplatesCommand, } from "../protocols/Aws_query";
-export class ListTemplatesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListTemplatesCommand = (function (_super) {
+    __extends(ListTemplatesCommand, _super);
+    function ListTemplatesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListTemplatesCommand.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 = "ListTemplatesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "ListTemplatesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListTemplatesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListTemplatesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListTemplatesCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryListTemplatesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListTemplatesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryListTemplatesCommand(output, context);
-    }
-}
+    };
+    return ListTemplatesCommand;
+}($Command));
+export { ListTemplatesCommand };

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

package/dist-es/commands/PutConfigurationSetDeliveryOptionsCommand.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 { PutConfigurationSetDeliveryOptionsRequestFilterSensitiveLog, PutConfigurationSetDeliveryOptionsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryPutConfigurationSetDeliveryOptionsCommand, serializeAws_queryPutConfigurationSetDeliveryOptionsCommand, } from "../protocols/Aws_query";
-export class PutConfigurationSetDeliveryOptionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutConfigurationSetDeliveryOptionsCommand = (function (_super) {
+    __extends(PutConfigurationSetDeliveryOptionsCommand, _super);
+    function PutConfigurationSetDeliveryOptionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutConfigurationSetDeliveryOptionsCommand.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 = "PutConfigurationSetDeliveryOptionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "PutConfigurationSetDeliveryOptionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutConfigurationSetDeliveryOptionsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PutConfigurationSetDeliveryOptionsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    PutConfigurationSetDeliveryOptionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryPutConfigurationSetDeliveryOptionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutConfigurationSetDeliveryOptionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryPutConfigurationSetDeliveryOptionsCommand(output, context);
-    }
-}
+    };
+    return PutConfigurationSetDeliveryOptionsCommand;
+}($Command));
+export { PutConfigurationSetDeliveryOptionsCommand };

package/dist-es/commands/PutIdentityPolicyCommand.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 { PutIdentityPolicyRequestFilterSensitiveLog, PutIdentityPolicyResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryPutIdentityPolicyCommand, serializeAws_queryPutIdentityPolicyCommand, } from "../protocols/Aws_query";
-export class PutIdentityPolicyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutIdentityPolicyCommand = (function (_super) {
+    __extends(PutIdentityPolicyCommand, _super);
+    function PutIdentityPolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutIdentityPolicyCommand.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 = "PutIdentityPolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "PutIdentityPolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutIdentityPolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PutIdentityPolicyResponseFilterSensitiveLog,
         };
-        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);
+    };
+    PutIdentityPolicyCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryPutIdentityPolicyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutIdentityPolicyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryPutIdentityPolicyCommand(output, context);
-    }
-}
+    };
+    return PutIdentityPolicyCommand;
+}($Command));
+export { PutIdentityPolicyCommand };

package/dist-es/commands/ReorderReceiptRuleSetCommand.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 { ReorderReceiptRuleSetRequestFilterSensitiveLog, ReorderReceiptRuleSetResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_queryReorderReceiptRuleSetCommand, serializeAws_queryReorderReceiptRuleSetCommand, } from "../protocols/Aws_query";
-export class ReorderReceiptRuleSetCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ReorderReceiptRuleSetCommand = (function (_super) {
+    __extends(ReorderReceiptRuleSetCommand, _super);
+    function ReorderReceiptRuleSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ReorderReceiptRuleSetCommand.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 = "ReorderReceiptRuleSetCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "ReorderReceiptRuleSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ReorderReceiptRuleSetRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ReorderReceiptRuleSetResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ReorderReceiptRuleSetCommand.prototype.serialize = function (input, context) {
         return serializeAws_queryReorderReceiptRuleSetCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ReorderReceiptRuleSetCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_queryReorderReceiptRuleSetCommand(output, context);
-    }
-}
+    };
+    return ReorderReceiptRuleSetCommand;
+}($Command));
+export { ReorderReceiptRuleSetCommand };

package/dist-es/commands/SendBounceCommand.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 { SendBounceRequestFilterSensitiveLog, SendBounceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_querySendBounceCommand, serializeAws_querySendBounceCommand } from "../protocols/Aws_query";
-export class SendBounceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SendBounceCommand = (function (_super) {
+    __extends(SendBounceCommand, _super);
+    function SendBounceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SendBounceCommand.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 = "SendBounceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "SendBounceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SendBounceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SendBounceResponseFilterSensitiveLog,
         };
-        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);
+    };
+    SendBounceCommand.prototype.serialize = function (input, context) {
         return serializeAws_querySendBounceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SendBounceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_querySendBounceCommand(output, context);
-    }
-}
+    };
+    return SendBounceCommand;
+}($Command));
+export { SendBounceCommand };

package/dist-es/commands/SendBulkTemplatedEmailCommand.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 { SendBulkTemplatedEmailRequestFilterSensitiveLog, SendBulkTemplatedEmailResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_querySendBulkTemplatedEmailCommand, serializeAws_querySendBulkTemplatedEmailCommand, } from "../protocols/Aws_query";
-export class SendBulkTemplatedEmailCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SendBulkTemplatedEmailCommand = (function (_super) {
+    __extends(SendBulkTemplatedEmailCommand, _super);
+    function SendBulkTemplatedEmailCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SendBulkTemplatedEmailCommand.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 = "SendBulkTemplatedEmailCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SESClient";
+        var commandName = "SendBulkTemplatedEmailCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SendBulkTemplatedEmailRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SendBulkTemplatedEmailResponseFilterSensitiveLog,
         };
-        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);
+    };
+    SendBulkTemplatedEmailCommand.prototype.serialize = function (input, context) {
         return serializeAws_querySendBulkTemplatedEmailCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SendBulkTemplatedEmailCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_querySendBulkTemplatedEmailCommand(output, context);
-    }
-}
+    };
+    return SendBulkTemplatedEmailCommand;
+}($Command));
+export { SendBulkTemplatedEmailCommand };

package/dist-es/commands/SendCustomVerificationEmailCommand.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 { SendCustomVerificationEmailRequestFilterSensitiveLog, SendCustomVerificationEmailResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_querySendCustomVerificationEmailCommand, serializeAws_querySendCustomVerificationEmailCommand, } from "../protocols/Aws_query";
-export class SendCustomVerificationEmailCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SendCustomVerificationEmailCommand = (function (_super) {
+    __extends(SendCustomVerificationEmailCommand, _super);
+    function SendCustomVerificationEmailCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SendCustomVerificationEmailCommand.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 = "SendCustomVerificationEmailCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: SendCustomVerificationEmailRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SendCustomVerificationEmailResponseFilterSensitiveLog,
         };
-        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);
+    };
+    SendCustomVerificationEmailCommand.prototype.serialize = function (input, context) {
         return serializeAws_querySendCustomVerificationEmailCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SendCustomVerificationEmailCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_querySendCustomVerificationEmailCommand(output, context);
-    }
-}
+    };
+    return SendCustomVerificationEmailCommand;
+}($Command));
+export { SendCustomVerificationEmailCommand };

package/dist-es/commands/SendEmailCommand.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 { SendEmailRequestFilterSensitiveLog, SendEmailResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_querySendEmailCommand, serializeAws_querySendEmailCommand } from "../protocols/Aws_query";
-export class SendEmailCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SendEmailCommand = (function (_super) {
+    __extends(SendEmailCommand, _super);
+    function SendEmailCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SendEmailCommand.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 = "SendEmailCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: SendEmailRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SendEmailResponseFilterSensitiveLog,
         };
-        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);
+    };
+    SendEmailCommand.prototype.serialize = function (input, context) {
         return serializeAws_querySendEmailCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SendEmailCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_querySendEmailCommand(output, context);
-    }
-}
+    };
+    return SendEmailCommand;
+}($Command));
+export { SendEmailCommand };