@aws-sdk/client-ses 3.32.0 → 3.36.0

package/dist-es/commands/UpdateConfigurationSetTrackingOptionsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateConfigurationSetTrackingOptionsRequest, UpdateConfigurationSetTrackingOptionsResponse, } 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;
+    }
+    UpdateConfigurationSetTrackingOptionsCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: UpdateConfigurationSetTrackingOptionsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateConfigurationSetTrackingOptionsResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    UpdateConfigurationSetTrackingOptionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateConfigurationSetTrackingOptionsCommand(output, context);
+    };
+    return UpdateConfigurationSetTrackingOptionsCommand;
+}($Command));
+export { UpdateConfigurationSetTrackingOptionsCommand };

package/dist-es/commands/UpdateCustomVerificationEmailTemplateCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateCustomVerificationEmailTemplateRequest } 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;
+    }
+    UpdateCustomVerificationEmailTemplateCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: UpdateCustomVerificationEmailTemplateRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        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);
+    };
+    UpdateCustomVerificationEmailTemplateCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateCustomVerificationEmailTemplateCommand(output, context);
+    };
+    return UpdateCustomVerificationEmailTemplateCommand;
+}($Command));
+export { UpdateCustomVerificationEmailTemplateCommand };

package/dist-es/commands/UpdateReceiptRuleCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateReceiptRuleRequest, UpdateReceiptRuleResponse } 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;
+    }
+    UpdateReceiptRuleCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: UpdateReceiptRuleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateReceiptRuleResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    UpdateReceiptRuleCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateReceiptRuleCommand(output, context);
+    };
+    return UpdateReceiptRuleCommand;
+}($Command));
+export { UpdateReceiptRuleCommand };

package/dist-es/commands/UpdateTemplateCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateTemplateRequest, UpdateTemplateResponse } 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;
+    }
+    UpdateTemplateCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: UpdateTemplateRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateTemplateResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    UpdateTemplateCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryUpdateTemplateCommand(output, context);
+    };
+    return UpdateTemplateCommand;
+}($Command));
+export { UpdateTemplateCommand };

package/dist-es/commands/VerifyDomainDkimCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { VerifyDomainDkimRequest, VerifyDomainDkimResponse } 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;
+    }
+    VerifyDomainDkimCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: VerifyDomainDkimRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: VerifyDomainDkimResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    VerifyDomainDkimCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryVerifyDomainDkimCommand(output, context);
+    };
+    return VerifyDomainDkimCommand;
+}($Command));
+export { VerifyDomainDkimCommand };

package/dist-es/commands/VerifyDomainIdentityCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { VerifyDomainIdentityRequest, VerifyDomainIdentityResponse } 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;
+    }
+    VerifyDomainIdentityCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: VerifyDomainIdentityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: VerifyDomainIdentityResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    VerifyDomainIdentityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryVerifyDomainIdentityCommand(output, context);
+    };
+    return VerifyDomainIdentityCommand;
+}($Command));
+export { VerifyDomainIdentityCommand };

package/dist-es/commands/VerifyEmailAddressCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { VerifyEmailAddressRequest } from "../models/models_0";
+import { deserializeAws_queryVerifyEmailAddressCommand, serializeAws_queryVerifyEmailAddressCommand, } from "../protocols/Aws_query";
+var VerifyEmailAddressCommand = (function (_super) {
+    __extends(VerifyEmailAddressCommand, _super);
+    function VerifyEmailAddressCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    VerifyEmailAddressCommand.prototype.resolveMiddleware = function (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 = "VerifyEmailAddressCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: VerifyEmailAddressRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    VerifyEmailAddressCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryVerifyEmailAddressCommand(input, context);
+    };
+    VerifyEmailAddressCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryVerifyEmailAddressCommand(output, context);
+    };
+    return VerifyEmailAddressCommand;
+}($Command));
+export { VerifyEmailAddressCommand };

package/dist-es/commands/VerifyEmailIdentityCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { VerifyEmailIdentityRequest, VerifyEmailIdentityResponse } from "../models/models_0";
+import { deserializeAws_queryVerifyEmailIdentityCommand, serializeAws_queryVerifyEmailIdentityCommand, } from "../protocols/Aws_query";
+var VerifyEmailIdentityCommand = (function (_super) {
+    __extends(VerifyEmailIdentityCommand, _super);
+    function VerifyEmailIdentityCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    VerifyEmailIdentityCommand.prototype.resolveMiddleware = function (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 = "VerifyEmailIdentityCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: VerifyEmailIdentityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: VerifyEmailIdentityResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    VerifyEmailIdentityCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryVerifyEmailIdentityCommand(input, context);
+    };
+    VerifyEmailIdentityCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryVerifyEmailIdentityCommand(output, context);
+    };
+    return VerifyEmailIdentityCommand;
+}($Command));
+export { VerifyEmailIdentityCommand };

package/dist-es/endpoints.js

@@ -0,0 +1,57 @@
+import { __assign, __awaiter, __generator } from "tslib";
+import { getRegionInfo } from "@aws-sdk/config-resolver";
+var regionHash = {
+    "fips-us-gov-west-1": {
+        hostname: "email-fips.us-gov-west-1.amazonaws.com",
+        signingRegion: "us-gov-west-1",
+    },
+};
+var partitionHash = {
+    aws: {
+        regions: [
+            "af-south-1",
+            "ap-east-1",
+            "ap-northeast-1",
+            "ap-northeast-2",
+            "ap-northeast-3",
+            "ap-south-1",
+            "ap-southeast-1",
+            "ap-southeast-2",
+            "ca-central-1",
+            "eu-central-1",
+            "eu-north-1",
+            "eu-south-1",
+            "eu-west-1",
+            "eu-west-2",
+            "eu-west-3",
+            "me-south-1",
+            "sa-east-1",
+            "us-east-1",
+            "us-east-2",
+            "us-west-1",
+            "us-west-2",
+        ],
+        hostname: "email.{region}.amazonaws.com",
+    },
+    "aws-cn": {
+        regions: ["cn-north-1", "cn-northwest-1"],
+        hostname: "email.{region}.amazonaws.com.cn",
+    },
+    "aws-iso": {
+        regions: ["us-iso-east-1"],
+        hostname: "email.{region}.c2s.ic.gov",
+    },
+    "aws-iso-b": {
+        regions: ["us-isob-east-1"],
+        hostname: "email.{region}.sc2s.sgov.gov",
+    },
+    "aws-us-gov": {
+        regions: ["fips-us-gov-west-1", "us-gov-east-1", "us-gov-west-1"],
+        hostname: "email.{region}.amazonaws.com",
+    },
+};
+export var defaultRegionInfoProvider = function (region, options) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2, getRegionInfo(region, __assign(__assign({}, options), { signingService: "ses", regionHash: regionHash, partitionHash: partitionHash }))];
+    });
+}); };