@aws-sdk/client-ses 3.181.0 → 3.183.0

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

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

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

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

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

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

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

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

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

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