@aws-sdk/client-ses 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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