@aws-sdk/client-ses 3.32.0 → 3.36.0

package/dist-cjs/commands/UpdateConfigurationSetSendingEnabledCommand.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateConfigurationSetSendingEnabledCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Enables or disables email sending for messages sent using a specific configuration set
+ *             in a given AWS Region. You can use this operation in conjunction with Amazon CloudWatch alarms
+ *             to temporarily pause email sending for a configuration set when the reputation metrics
+ *             for that configuration set (such as your bounce on complaint rate) exceed certain
+ *             thresholds.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, UpdateConfigurationSetSendingEnabledCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, UpdateConfigurationSetSendingEnabledCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new UpdateConfigurationSetSendingEnabledCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateConfigurationSetSendingEnabledCommandInput} for command's `input` shape.
+ * @see {@link UpdateConfigurationSetSendingEnabledCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UpdateConfigurationSetSendingEnabledCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.UpdateConfigurationSetSendingEnabledRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: (output) => output,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryUpdateConfigurationSetSendingEnabledCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryUpdateConfigurationSetSendingEnabledCommand(output, context);
+    }
+}
+exports.UpdateConfigurationSetSendingEnabledCommand = UpdateConfigurationSetSendingEnabledCommand;

package/dist-cjs/commands/UpdateConfigurationSetTrackingOptionsCommand.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateConfigurationSetTrackingOptionsCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Modifies an association between a configuration set and a custom domain for open and
+ *             click event tracking. </p>
+ *         <p>By default, images and links used for tracking open and click events are hosted on
+ *             domains operated by Amazon SES. You can configure a subdomain of your own to handle these
+ *             events. For information about using custom domains, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/configure-custom-open-click-domains.html">Amazon SES Developer Guide</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, UpdateConfigurationSetTrackingOptionsCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, UpdateConfigurationSetTrackingOptionsCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new UpdateConfigurationSetTrackingOptionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateConfigurationSetTrackingOptionsCommandInput} for command's `input` shape.
+ * @see {@link UpdateConfigurationSetTrackingOptionsCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UpdateConfigurationSetTrackingOptionsCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.UpdateConfigurationSetTrackingOptionsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.UpdateConfigurationSetTrackingOptionsResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryUpdateConfigurationSetTrackingOptionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryUpdateConfigurationSetTrackingOptionsCommand(output, context);
+    }
+}
+exports.UpdateConfigurationSetTrackingOptionsCommand = UpdateConfigurationSetTrackingOptionsCommand;

package/dist-cjs/commands/UpdateCustomVerificationEmailTemplateCommand.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCustomVerificationEmailTemplateCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Updates an existing custom verification email template.</p>
+ *         <p>For more information about custom verification email templates, see <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/custom-verification-emails.html">Using Custom Verification Email Templates</a> in the <i>Amazon SES Developer
+ *                 Guide</i>.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, UpdateCustomVerificationEmailTemplateCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, UpdateCustomVerificationEmailTemplateCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new UpdateCustomVerificationEmailTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateCustomVerificationEmailTemplateCommandInput} for command's `input` shape.
+ * @see {@link UpdateCustomVerificationEmailTemplateCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UpdateCustomVerificationEmailTemplateCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.UpdateCustomVerificationEmailTemplateRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: (output) => output,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryUpdateCustomVerificationEmailTemplateCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryUpdateCustomVerificationEmailTemplateCommand(output, context);
+    }
+}
+exports.UpdateCustomVerificationEmailTemplateCommand = UpdateCustomVerificationEmailTemplateCommand;

package/dist-cjs/commands/UpdateReceiptRuleCommand.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateReceiptRuleCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Updates a receipt rule.</p>
+ *         <p>For information about managing receipt rules, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-managing-receipt-rules.html">Amazon SES
+ *                 Developer Guide</a>.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, UpdateReceiptRuleCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, UpdateReceiptRuleCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new UpdateReceiptRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateReceiptRuleCommandInput} for command's `input` shape.
+ * @see {@link UpdateReceiptRuleCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UpdateReceiptRuleCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.UpdateReceiptRuleRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.UpdateReceiptRuleResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryUpdateReceiptRuleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryUpdateReceiptRuleCommand(output, context);
+    }
+}
+exports.UpdateReceiptRuleCommand = UpdateReceiptRuleCommand;

package/dist-cjs/commands/UpdateTemplateCommand.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateTemplateCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Updates an email template. Email templates enable you to send personalized email to
+ *             one or more destinations in a single API operation. For more information, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html">Amazon SES Developer
+ *                 Guide</a>.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, UpdateTemplateCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, UpdateTemplateCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new UpdateTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateTemplateCommandInput} for command's `input` shape.
+ * @see {@link UpdateTemplateCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class UpdateTemplateCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.UpdateTemplateRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.UpdateTemplateResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryUpdateTemplateCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryUpdateTemplateCommand(output, context);
+    }
+}
+exports.UpdateTemplateCommand = UpdateTemplateCommand;

package/dist-cjs/commands/VerifyDomainDkimCommand.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyDomainDkimCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Returns a set of DKIM tokens for a domain identity.</p>
+ *         <important>
+ *             <p>When you execute the <code>VerifyDomainDkim</code> operation, the domain that you
+ *                 specify is added to the list of identities that are associated with your account.
+ *                 This is true even if you haven't already associated the domain with your account by
+ *                 using the <code>VerifyDomainIdentity</code> operation. However, you can't send email
+ *                 from the domain until you either successfully <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-domains.html">verify it</a> or you
+ *                 successfully <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">set up DKIM for
+ *                 it</a>.</p>
+ *         </important>
+ *         <p>You use the tokens that are generated by this operation to create CNAME records. When
+ *             Amazon SES detects that you've added these records to the DNS configuration for a domain, you
+ *             can start sending email from that domain. You can start sending email even if you
+ *             haven't added the TXT record provided by the VerifyDomainIdentity operation to the DNS
+ *             configuration for your domain. All email that you send from the domain is authenticated
+ *             using DKIM.</p>
+ *         <p>To create the CNAME records for DKIM authentication, use the following values:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>
+ *                   <b>Name</b>:
+ *                         <i>token</i>._domainkey.<i>example.com</i>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <b>Type</b>: CNAME</p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <b>Value</b>:
+ *                     <i>token</i>.dkim.amazonses.com</p>
+ *             </li>
+ *          </ul>
+ *         <p>In the preceding example, replace <i>token</i> with one of the tokens
+ *             that are generated when you execute this operation. Replace
+ *                 <i>example.com</i> with your domain. Repeat this process for each
+ *             token that's generated by this operation.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, VerifyDomainDkimCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, VerifyDomainDkimCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new VerifyDomainDkimCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link VerifyDomainDkimCommandInput} for command's `input` shape.
+ * @see {@link VerifyDomainDkimCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class VerifyDomainDkimCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.VerifyDomainDkimRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.VerifyDomainDkimResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryVerifyDomainDkimCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryVerifyDomainDkimCommand(output, context);
+    }
+}
+exports.VerifyDomainDkimCommand = VerifyDomainDkimCommand;

package/dist-cjs/commands/VerifyDomainIdentityCommand.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyDomainIdentityCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Adds a domain to the list of identities for your Amazon SES account in the current AWS
+ *             Region and attempts to verify it. For more information about verifying domains, see
+ *                 <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html">Verifying Email
+ *                 Addresses and Domains</a> in the <i>Amazon SES Developer
+ *             Guide.</i>
+ *          </p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, VerifyDomainIdentityCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, VerifyDomainIdentityCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new VerifyDomainIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link VerifyDomainIdentityCommandInput} for command's `input` shape.
+ * @see {@link VerifyDomainIdentityCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class VerifyDomainIdentityCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.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,
+            inputFilterSensitiveLog: models_0_1.VerifyDomainIdentityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.VerifyDomainIdentityResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryVerifyDomainIdentityCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryVerifyDomainIdentityCommand(output, context);
+    }
+}
+exports.VerifyDomainIdentityCommand = VerifyDomainIdentityCommand;

package/dist-cjs/commands/VerifyEmailAddressCommand.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyEmailAddressCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Deprecated. Use the <code>VerifyEmailIdentity</code> operation to verify a new email
+ *             address.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, VerifyEmailAddressCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, VerifyEmailAddressCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new VerifyEmailAddressCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link VerifyEmailAddressCommandInput} for command's `input` shape.
+ * @see {@link VerifyEmailAddressCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class VerifyEmailAddressCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "VerifyEmailAddressCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.VerifyEmailAddressRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: (output) => output,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryVerifyEmailAddressCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryVerifyEmailAddressCommand(output, context);
+    }
+}
+exports.VerifyEmailAddressCommand = VerifyEmailAddressCommand;

package/dist-cjs/commands/VerifyEmailIdentityCommand.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyEmailIdentityCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_query_1 = require("../protocols/Aws_query");
+/**
+ * <p>Adds an email address to the list of identities for your Amazon SES account in the current
+ *             AWS region and attempts to verify it. As a result of executing this operation, a
+ *             verification email is sent to the specified address.</p>
+ *         <p>You can execute this operation no more than once per second.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, VerifyEmailIdentityCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, VerifyEmailIdentityCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new VerifyEmailIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link VerifyEmailIdentityCommandInput} for command's `input` shape.
+ * @see {@link VerifyEmailIdentityCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class VerifyEmailIdentityCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SESClient";
+        const commandName = "VerifyEmailIdentityCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.VerifyEmailIdentityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.VerifyEmailIdentityResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryVerifyEmailIdentityCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryVerifyEmailIdentityCommand(output, context);
+    }
+}
+exports.VerifyEmailIdentityCommand = VerifyEmailIdentityCommand;