@aws-sdk/client-ses 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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