@aws-sdk/client-ses 3.32.0 → 3.36.0

package/dist-cjs/commands/ListReceiptFiltersCommand.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListReceiptFiltersCommand = 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>Lists the IP address filters associated with your AWS account in the current AWS
+ *             Region.</p>
+ *         <p>For information about managing IP address filters, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-managing-ip-filters.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, ListReceiptFiltersCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, ListReceiptFiltersCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new ListReceiptFiltersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListReceiptFiltersCommandInput} for command's `input` shape.
+ * @see {@link ListReceiptFiltersCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class ListReceiptFiltersCommand 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 = "ListReceiptFiltersCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.ListReceiptFiltersRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.ListReceiptFiltersResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryListReceiptFiltersCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryListReceiptFiltersCommand(output, context);
+    }
+}
+exports.ListReceiptFiltersCommand = ListReceiptFiltersCommand;

package/dist-cjs/commands/ListReceiptRuleSetsCommand.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListReceiptRuleSetsCommand = 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>Lists the receipt rule sets that exist under your AWS account in the current AWS
+ *             Region. If there are additional receipt rule sets to be retrieved, you will receive a
+ *                 <code>NextToken</code> that you can provide to the next call to
+ *                 <code>ListReceiptRuleSets</code> to retrieve the additional entries.</p>
+ *         <p>For information about managing receipt rule sets, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-managing-receipt-rule-sets.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, ListReceiptRuleSetsCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, ListReceiptRuleSetsCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new ListReceiptRuleSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListReceiptRuleSetsCommandInput} for command's `input` shape.
+ * @see {@link ListReceiptRuleSetsCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class ListReceiptRuleSetsCommand 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 = "ListReceiptRuleSetsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.ListReceiptRuleSetsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.ListReceiptRuleSetsResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryListReceiptRuleSetsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryListReceiptRuleSetsCommand(output, context);
+    }
+}
+exports.ListReceiptRuleSetsCommand = ListReceiptRuleSetsCommand;

package/dist-cjs/commands/ListTemplatesCommand.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListTemplatesCommand = 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>Lists the email templates present in your Amazon SES account in the current AWS
+ *             Region.</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, ListTemplatesCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, ListTemplatesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new ListTemplatesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTemplatesCommandInput} for command's `input` shape.
+ * @see {@link ListTemplatesCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class ListTemplatesCommand 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 = "ListTemplatesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.ListTemplatesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.ListTemplatesResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryListTemplatesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryListTemplatesCommand(output, context);
+    }
+}
+exports.ListTemplatesCommand = ListTemplatesCommand;

package/dist-cjs/commands/ListVerifiedEmailAddressesCommand.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListVerifiedEmailAddressesCommand = 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>ListIdentities</code> operation to list the email addresses
+ *             and domains associated with your account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, ListVerifiedEmailAddressesCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, ListVerifiedEmailAddressesCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new ListVerifiedEmailAddressesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListVerifiedEmailAddressesCommandInput} for command's `input` shape.
+ * @see {@link ListVerifiedEmailAddressesCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class ListVerifiedEmailAddressesCommand 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 = "ListVerifiedEmailAddressesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (input) => input,
+            outputFilterSensitiveLog: models_0_1.ListVerifiedEmailAddressesResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryListVerifiedEmailAddressesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryListVerifiedEmailAddressesCommand(output, context);
+    }
+}
+exports.ListVerifiedEmailAddressesCommand = ListVerifiedEmailAddressesCommand;

package/dist-cjs/commands/PutConfigurationSetDeliveryOptionsCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PutConfigurationSetDeliveryOptionsCommand = 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 or updates the delivery options for a configuration set.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, PutConfigurationSetDeliveryOptionsCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, PutConfigurationSetDeliveryOptionsCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new PutConfigurationSetDeliveryOptionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutConfigurationSetDeliveryOptionsCommandInput} for command's `input` shape.
+ * @see {@link PutConfigurationSetDeliveryOptionsCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class PutConfigurationSetDeliveryOptionsCommand 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 = "PutConfigurationSetDeliveryOptionsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.PutConfigurationSetDeliveryOptionsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.PutConfigurationSetDeliveryOptionsResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryPutConfigurationSetDeliveryOptionsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryPutConfigurationSetDeliveryOptionsCommand(output, context);
+    }
+}
+exports.PutConfigurationSetDeliveryOptionsCommand = PutConfigurationSetDeliveryOptionsCommand;

package/dist-cjs/commands/PutIdentityPolicyCommand.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PutIdentityPolicyCommand = 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 or updates a sending authorization policy for the specified identity (an email
+ *             address or a domain).</p>
+ *         <note>
+ *             <p>This API is for the identity owner only. If you have not verified the identity,
+ *                 this API will return an error.</p>
+ *         </note>
+ *         <p>Sending authorization is a feature that enables an identity owner to authorize other
+ *             senders to use its identities. For information about using sending authorization, see
+ *             the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.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, PutIdentityPolicyCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, PutIdentityPolicyCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new PutIdentityPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutIdentityPolicyCommandInput} for command's `input` shape.
+ * @see {@link PutIdentityPolicyCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class PutIdentityPolicyCommand 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 = "PutIdentityPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.PutIdentityPolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.PutIdentityPolicyResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryPutIdentityPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryPutIdentityPolicyCommand(output, context);
+    }
+}
+exports.PutIdentityPolicyCommand = PutIdentityPolicyCommand;

package/dist-cjs/commands/ReorderReceiptRuleSetCommand.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReorderReceiptRuleSetCommand = 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>Reorders the receipt rules within a receipt rule set.</p>
+ *         <note>
+ *             <p>All of the rules in the rule set must be represented in this request. That is,
+ *                 this API will return an error if the reorder request doesn't explicitly position all
+ *                 of the rules.</p>
+ *         </note>
+ *         <p>For information about managing receipt rule sets, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-managing-receipt-rule-sets.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, ReorderReceiptRuleSetCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, ReorderReceiptRuleSetCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new ReorderReceiptRuleSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ReorderReceiptRuleSetCommandInput} for command's `input` shape.
+ * @see {@link ReorderReceiptRuleSetCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class ReorderReceiptRuleSetCommand 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 = "ReorderReceiptRuleSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.ReorderReceiptRuleSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.ReorderReceiptRuleSetResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_queryReorderReceiptRuleSetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_queryReorderReceiptRuleSetCommand(output, context);
+    }
+}
+exports.ReorderReceiptRuleSetCommand = ReorderReceiptRuleSetCommand;

package/dist-cjs/commands/SendBounceCommand.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendBounceCommand = 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>Generates and sends a bounce message to the sender of an email you received through
+ *             Amazon SES. You can only use this API on an email up to 24 hours after you receive it.</p>
+ *         <note>
+ *             <p>You cannot use this API to send generic bounces for mail that was not received by
+ *                 Amazon SES.</p>
+ *         </note>
+ *         <p>For information about receiving email through Amazon SES, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email.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, SendBounceCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, SendBounceCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new SendBounceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SendBounceCommandInput} for command's `input` shape.
+ * @see {@link SendBounceCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class SendBounceCommand 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 = "SendBounceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.SendBounceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.SendBounceResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_querySendBounceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_querySendBounceCommand(output, context);
+    }
+}
+exports.SendBounceCommand = SendBounceCommand;

package/dist-cjs/commands/SendBulkTemplatedEmailCommand.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendBulkTemplatedEmailCommand = 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>Composes an email message to multiple destinations. The message body is created using
+ *             an email template.</p>
+ *         <p>In order to send email using the <code>SendBulkTemplatedEmail</code> operation, your
+ *             call to the API must meet the following requirements:</p>
+ *         <ul>
+ *             <li>
+ *                 <p>The call must refer to an existing email template. You can create email
+ *                     templates using the <a>CreateTemplate</a> operation.</p>
+ *             </li>
+ *             <li>
+ *                 <p>The message must be sent from a verified email address or domain.</p>
+ *             </li>
+ *             <li>
+ *                 <p>If your account is still in the Amazon SES sandbox, you may only send to verified
+ *                     addresses or domains, or to email addresses associated with the Amazon SES Mailbox
+ *                     Simulator. For more information, 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>
+ *             </li>
+ *             <li>
+ *                 <p>The maximum message size is 10 MB.</p>
+ *             </li>
+ *             <li>
+ *                 <p>Each <code>Destination</code> parameter must include at least one recipient
+ *                     email address. The recipient address can be a To: address, a CC: address, or a
+ *                     BCC: address. If a recipient email address is invalid (that is, it is not in the
+ *                     format <i>UserName@[SubDomain.]Domain.TopLevelDomain</i>), the
+ *                     entire message will be rejected, even if the message contains other recipients
+ *                     that are valid.</p>
+ *             </li>
+ *             <li>
+ *                 <p>The message may not include more than 50 recipients, across the To:, CC: and
+ *                     BCC: fields. If you need to send an email message to a larger audience, you can
+ *                     divide your recipient list into groups of 50 or fewer, and then call the
+ *                         <code>SendBulkTemplatedEmail</code> operation several times to send the
+ *                     message to each group.</p>
+ *             </li>
+ *             <li>
+ *                 <p>The number of destinations you can contact in a single call to the API may be
+ *                     limited by your account's maximum sending rate.</p>
+ *             </li>
+ *          </ul>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { SESClient, SendBulkTemplatedEmailCommand } from "@aws-sdk/client-ses"; // ES Modules import
+ * // const { SESClient, SendBulkTemplatedEmailCommand } = require("@aws-sdk/client-ses"); // CommonJS import
+ * const client = new SESClient(config);
+ * const command = new SendBulkTemplatedEmailCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SendBulkTemplatedEmailCommandInput} for command's `input` shape.
+ * @see {@link SendBulkTemplatedEmailCommandOutput} for command's `response` shape.
+ * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class SendBulkTemplatedEmailCommand 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 = "SendBulkTemplatedEmailCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.SendBulkTemplatedEmailRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.SendBulkTemplatedEmailResponse.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_query_1.serializeAws_querySendBulkTemplatedEmailCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_query_1.deserializeAws_querySendBulkTemplatedEmailCommand(output, context);
+    }
+}
+exports.SendBulkTemplatedEmailCommand = SendBulkTemplatedEmailCommand;