@aws-sdk/client-ses 3.32.0 → 3.36.0

package/dist/es/commands/SendBulkTemplatedEmailCommand.js

@@ -1,107 +0,0 @@
-import { __extends } from "tslib";
-import { SendBulkTemplatedEmailRequest, SendBulkTemplatedEmailResponse } from "../models/models_0";
-import { deserializeAws_querySendBulkTemplatedEmailCommand, serializeAws_querySendBulkTemplatedEmailCommand, } from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <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.
- *
- */
-var SendBulkTemplatedEmailCommand = /** @class */ (function (_super) {
-    __extends(SendBulkTemplatedEmailCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
-    function SendBulkTemplatedEmailCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
-        _this.input = input;
-        return _this;
-        // End section: command_constructor
-    }
-    /**
-     * @internal
-     */
-    SendBulkTemplatedEmailCommand.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 = "SendBulkTemplatedEmailCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
-            inputFilterSensitiveLog: SendBulkTemplatedEmailRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: SendBulkTemplatedEmailResponse.filterSensitiveLog,
-        };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SendBulkTemplatedEmailCommand.prototype.serialize = function (input, context) {
-        return serializeAws_querySendBulkTemplatedEmailCommand(input, context);
-    };
-    SendBulkTemplatedEmailCommand.prototype.deserialize = function (output, context) {
-        return deserializeAws_querySendBulkTemplatedEmailCommand(output, context);
-    };
-    return SendBulkTemplatedEmailCommand;
-}($Command));
-export { SendBulkTemplatedEmailCommand };
-//# sourceMappingURL=SendBulkTemplatedEmailCommand.js.map

package/dist/es/commands/SendBulkTemplatedEmailCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SendBulkTemplatedEmailCommand.js","sourceRoot":"","sources":["../../../commands/SendBulkTemplatedEmailCommand.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,6BAA6B,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AACnG,OAAO,EACL,iDAAiD,EACjD,+CAA+C,GAChD,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAc7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH;IAAmD,iDAIlD;IACC,oCAAoC;IACpC,kCAAkC;IAElC,uCAAqB,KAAyC;QAA9D;QACE,qCAAqC;QACrC,iBAAO,SAER;QAJoB,WAAK,GAAL,KAAK,CAAoC;;QAG5D,mCAAmC;IACrC,CAAC;IAED;;OAEG;IACH,yDAAiB,GAAjB,UACE,WAAmE,EACnE,aAAsC,EACtC,OAA8B;QAE9B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAE1F,IAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE/C,IAAA,MAAM,GAAK,aAAa,OAAlB,CAAmB;QACjC,IAAM,UAAU,GAAG,WAAW,CAAC;QAC/B,IAAM,WAAW,GAAG,+BAA+B,CAAC;QACpD,IAAM,uBAAuB,GAA4B;YACvD,MAAM,QAAA;YACN,UAAU,YAAA;YACV,WAAW,aAAA;YACX,uBAAuB,EAAE,6BAA6B,CAAC,kBAAkB;YACzE,wBAAwB,EAAE,8BAA8B,CAAC,kBAAkB;SAC5E,CAAC;QACM,IAAA,cAAc,GAAK,aAAa,eAAlB,CAAmB;QACzC,OAAO,KAAK,CAAC,OAAO,CAClB,UAAC,OAAsC;YACrC,OAAA,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,OAAwB,EAAE,OAAO,IAAI,EAAE,CAAC;QAAtE,CAAsE,EACxE,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAEO,iDAAS,GAAjB,UAAkB,KAAyC,EAAE,OAAuB;QAClF,OAAO,+CAA+C,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACzE,CAAC;IAEO,mDAAW,GAAnB,UAAoB,MAAsB,EAAE,OAAuB;QACjE,OAAO,iDAAiD,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;IAIH,oCAAC;AAAD,CAAC,AAtDD,CAAmD,QAAQ,GAsD1D"}

package/dist/es/commands/SendCustomVerificationEmailCommand.js

@@ -1,73 +0,0 @@
-import { __extends } from "tslib";
-import { SendCustomVerificationEmailRequest, SendCustomVerificationEmailResponse } from "../models/models_0";
-import { deserializeAws_querySendCustomVerificationEmailCommand, serializeAws_querySendCustomVerificationEmailCommand, } from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <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
- *             customized verification email is sent to the specified address.</p>
- *         <p>To use this operation, you must first create a custom verification email template. For
- *             more information about creating and using 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, SendCustomVerificationEmailCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SendCustomVerificationEmailCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SendCustomVerificationEmailCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendCustomVerificationEmailCommandInput} for command's `input` shape.
- * @see {@link SendCustomVerificationEmailCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var SendCustomVerificationEmailCommand = /** @class */ (function (_super) {
-    __extends(SendCustomVerificationEmailCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
-    function SendCustomVerificationEmailCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
-        _this.input = input;
-        return _this;
-        // End section: command_constructor
-    }
-    /**
-     * @internal
-     */
-    SendCustomVerificationEmailCommand.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 = "SendCustomVerificationEmailCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
-            inputFilterSensitiveLog: SendCustomVerificationEmailRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: SendCustomVerificationEmailResponse.filterSensitiveLog,
-        };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SendCustomVerificationEmailCommand.prototype.serialize = function (input, context) {
-        return serializeAws_querySendCustomVerificationEmailCommand(input, context);
-    };
-    SendCustomVerificationEmailCommand.prototype.deserialize = function (output, context) {
-        return deserializeAws_querySendCustomVerificationEmailCommand(output, context);
-    };
-    return SendCustomVerificationEmailCommand;
-}($Command));
-export { SendCustomVerificationEmailCommand };
-//# sourceMappingURL=SendCustomVerificationEmailCommand.js.map

package/dist/es/commands/SendCustomVerificationEmailCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SendCustomVerificationEmailCommand.js","sourceRoot":"","sources":["../../../commands/SendCustomVerificationEmailCommand.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,kCAAkC,EAAE,mCAAmC,EAAE,MAAM,oBAAoB,CAAC;AAC7G,OAAO,EACL,sDAAsD,EACtD,oDAAoD,GACrD,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAgB7D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAAwD,sDAIvD;IACC,oCAAoC;IACpC,kCAAkC;IAElC,4CAAqB,KAA8C;QAAnE;QACE,qCAAqC;QACrC,iBAAO,SAER;QAJoB,WAAK,GAAL,KAAK,CAAyC;;QAGjE,mCAAmC;IACrC,CAAC;IAED;;OAEG;IACH,8DAAiB,GAAjB,UACE,WAAmE,EACnE,aAAsC,EACtC,OAA8B;QAE9B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAE1F,IAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE/C,IAAA,MAAM,GAAK,aAAa,OAAlB,CAAmB;QACjC,IAAM,UAAU,GAAG,WAAW,CAAC;QAC/B,IAAM,WAAW,GAAG,oCAAoC,CAAC;QACzD,IAAM,uBAAuB,GAA4B;YACvD,MAAM,QAAA;YACN,UAAU,YAAA;YACV,WAAW,aAAA;YACX,uBAAuB,EAAE,kCAAkC,CAAC,kBAAkB;YAC9E,wBAAwB,EAAE,mCAAmC,CAAC,kBAAkB;SACjF,CAAC;QACM,IAAA,cAAc,GAAK,aAAa,eAAlB,CAAmB;QACzC,OAAO,KAAK,CAAC,OAAO,CAClB,UAAC,OAAsC;YACrC,OAAA,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,OAAwB,EAAE,OAAO,IAAI,EAAE,CAAC;QAAtE,CAAsE,EACxE,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAEO,sDAAS,GAAjB,UAAkB,KAA8C,EAAE,OAAuB;QACvF,OAAO,oDAAoD,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC9E,CAAC;IAEO,wDAAW,GAAnB,UACE,MAAsB,EACtB,OAAuB;QAEvB,OAAO,sDAAsD,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjF,CAAC;IAIH,yCAAC;AAAD,CAAC,AAzDD,CAAwD,QAAQ,GAyD/D"}

package/dist/es/commands/SendEmailCommand.js

@@ -1,109 +0,0 @@
-import { __extends } from "tslib";
-import { SendEmailRequest, SendEmailResponse } from "../models/models_0";
-import { deserializeAws_querySendEmailCommand, serializeAws_querySendEmailCommand } from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Composes an email message and immediately queues it for sending. In order to send
- *             email using the <code>SendEmail</code> operation, your message must meet the following
- *             requirements:</p>
- *
- *         <ul>
- *             <li>
- *                 <p>The message must be sent from a verified email address or domain. If you
- *                     attempt to send email using a non-verified address or domain, the operation will
- *                     result in an "Email address not verified" error. </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>The message 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>SendEmail</code> operation several times to send the message to each
- *                     group.</p>
- *             </li>
- *          </ul>
- *         <important>
- *             <p>For every message that you send, the total number of recipients (including each
- *                 recipient in the To:, CC: and BCC: fields) is counted against the maximum number of
- *                 emails you can send in a 24-hour period (your <i>sending quota</i>).
- *                 For more information about sending quotas in Amazon SES, see <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/manage-sending-limits.html">Managing Your Amazon SES
- *                     Sending Limits</a> in the <i>Amazon SES Developer Guide.</i>
- *             </p>
- *         </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, SendEmailCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SendEmailCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SendEmailCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendEmailCommandInput} for command's `input` shape.
- * @see {@link SendEmailCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var SendEmailCommand = /** @class */ (function (_super) {
-    __extends(SendEmailCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
-    function SendEmailCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
-        _this.input = input;
-        return _this;
-        // End section: command_constructor
-    }
-    /**
-     * @internal
-     */
-    SendEmailCommand.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 = "SendEmailCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
-            inputFilterSensitiveLog: SendEmailRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: SendEmailResponse.filterSensitiveLog,
-        };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SendEmailCommand.prototype.serialize = function (input, context) {
-        return serializeAws_querySendEmailCommand(input, context);
-    };
-    SendEmailCommand.prototype.deserialize = function (output, context) {
-        return deserializeAws_querySendEmailCommand(output, context);
-    };
-    return SendEmailCommand;
-}($Command));
-export { SendEmailCommand };
-//# sourceMappingURL=SendEmailCommand.js.map

package/dist/es/commands/SendEmailCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SendEmailCommand.js","sourceRoot":"","sources":["../../../commands/SendEmailCommand.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,oCAAoC,EAAE,kCAAkC,EAAE,MAAM,wBAAwB,CAAC;AAClH,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAc7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH;IAAsC,oCAAgF;IACpH,oCAAoC;IACpC,kCAAkC;IAElC,0BAAqB,KAA4B;QAAjD;QACE,qCAAqC;QACrC,iBAAO,SAER;QAJoB,WAAK,GAAL,KAAK,CAAuB;;QAG/C,mCAAmC;IACrC,CAAC;IAED;;OAEG;IACH,4CAAiB,GAAjB,UACE,WAAmE,EACnE,aAAsC,EACtC,OAA8B;QAE9B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAE1F,IAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE/C,IAAA,MAAM,GAAK,aAAa,OAAlB,CAAmB;QACjC,IAAM,UAAU,GAAG,WAAW,CAAC;QAC/B,IAAM,WAAW,GAAG,kBAAkB,CAAC;QACvC,IAAM,uBAAuB,GAA4B;YACvD,MAAM,QAAA;YACN,UAAU,YAAA;YACV,WAAW,aAAA;YACX,uBAAuB,EAAE,gBAAgB,CAAC,kBAAkB;YAC5D,wBAAwB,EAAE,iBAAiB,CAAC,kBAAkB;SAC/D,CAAC;QACM,IAAA,cAAc,GAAK,aAAa,eAAlB,CAAmB;QACzC,OAAO,KAAK,CAAC,OAAO,CAClB,UAAC,OAAsC;YACrC,OAAA,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,OAAwB,EAAE,OAAO,IAAI,EAAE,CAAC;QAAtE,CAAsE,EACxE,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAEO,oCAAS,GAAjB,UAAkB,KAA4B,EAAE,OAAuB;QACrE,OAAO,kCAAkC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC5D,CAAC;IAEO,sCAAW,GAAnB,UAAoB,MAAsB,EAAE,OAAuB;QACjE,OAAO,oCAAoC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/D,CAAC;IAIH,uBAAC;AAAD,CAAC,AAlDD,CAAsC,QAAQ,GAkD7C"}

package/dist/es/commands/SendRawEmailCommand.js

@@ -1,173 +0,0 @@
-import { __extends } from "tslib";
-import { SendRawEmailRequest, SendRawEmailResponse } from "../models/models_0";
-import { deserializeAws_querySendRawEmailCommand, serializeAws_querySendRawEmailCommand } from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Composes an email message and immediately queues it for sending.</p>
- *
- *         <p>This operation is more flexible than the <code>SendEmail</code> API operation. When
- *             you use the <code>SendRawEmail</code> operation, you can specify the headers of the
- *             message as well as its content. This flexibility is useful, for example, when you want
- *             to send a multipart MIME email (such a message that contains both a text and an HTML
- *             version). You can also use this operation to send messages that include
- *             attachments.</p>
- *         <p>The <code>SendRawEmail</code> operation has the following requirements:</p>
- *         <ul>
- *             <li>
- *                 <p>You can only send email from <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html">verified email addresses or domains</a>. If you try
- *                     to send email from an address that isn't verified, the operation results in an
- *                     "Email address not verified" error.</p>
- *             </li>
- *             <li>
- *                 <p>If your account is still in the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/request-production-access.html">Amazon SES sandbox</a>, you can only send email to other
- *                     verified addresses in your account, or to addresses that are associated with the
- *                         <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/mailbox-simulator.html">Amazon SES mailbox simulator</a>.</p>
- *             </li>
- *             <li>
- *                 <p>The maximum message size, including attachments, is 10 MB.</p>
- *             </li>
- *             <li>
- *                 <p>Each message has to include at least one recipient address. A recipient
- *                     address includes any address on the To:, CC:, or BCC: lines.</p>
- *             </li>
- *             <li>
- *                 <p>If you send a single message to more than one recipient address, and one of
- *                     the recipient addresses isn't in a valid format (that is, it's not in the format
- *                         <i>UserName@[SubDomain.]Domain.TopLevelDomain</i>), Amazon SES
- *                     rejects the entire message, even if the other addresses are valid.</p>
- *             </li>
- *             <li>
- *                 <p>Each message can include up to 50 recipient addresses across the To:, CC:, or
- *                     BCC: lines. If you need to send a single message to more than 50 recipients, you
- *                     have to split the list of recipient addresses into groups of less than 50
- *                     recipients, and send separate messages to each group.</p>
- *             </li>
- *             <li>
- *                 <p>Amazon SES allows you to specify 8-bit Content-Transfer-Encoding for MIME message
- *                     parts. However, if Amazon SES has to modify the contents of your message (for
- *                     example, if you use open and click tracking), 8-bit content isn't preserved. For
- *                     this reason, we highly recommend that you encode all content that isn't 7-bit
- *                     ASCII. For more information, see <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html#send-email-mime-encoding">MIME Encoding</a> in the <i>Amazon SES Developer
- *                         Guide</i>.</p>
- *             </li>
- *          </ul>
- *
- *
- *
- *         <p>Additionally, keep the following considerations in mind when using the
- *                 <code>SendRawEmail</code> operation:</p>
- *
- *         <ul>
- *             <li>
- *                 <p>Although you can customize the message headers when using the
- *                         <code>SendRawEmail</code> operation, Amazon SES will automatically apply its own
- *                         <code>Message-ID</code> and <code>Date</code> headers; if you passed these
- *                     headers when creating the message, they will be overwritten by the values that
- *                     Amazon SES provides.</p>
- *             </li>
- *             <li>
- *                 <p>If you are using sending authorization to send on behalf of another user,
- *                         <code>SendRawEmail</code> enables you to specify the cross-account identity
- *                     for the email's Source, From, and Return-Path parameters in one of two ways: you
- *                     can pass optional parameters <code>SourceArn</code>, <code>FromArn</code>,
- *                     and/or <code>ReturnPathArn</code> to the API, or you can include the following
- *                     X-headers in the header of your raw email:</p>
- *                 <ul>
- *                   <li>
- *                         <p>
- *                             <code>X-SES-SOURCE-ARN</code>
- *                         </p>
- *                     </li>
- *                   <li>
- *                         <p>
- *                             <code>X-SES-FROM-ARN</code>
- *                         </p>
- *                     </li>
- *                   <li>
- *                         <p>
- *                             <code>X-SES-RETURN-PATH-ARN</code>
- *                         </p>
- *                     </li>
- *                </ul>
- *                 <important>
- *                     <p>Don't include these X-headers in the DKIM signature. Amazon SES removes these
- *                         before it sends the email.</p>
- *                 </important>
- *                 <p>If you only specify the <code>SourceIdentityArn</code> parameter, Amazon SES sets
- *                     the From and Return-Path addresses to the same identity that you
- *                     specified.</p>
- *                 <p>For more information about sending authorization, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html">Using Sending
- *                         Authorization with Amazon SES</a> in the <i>Amazon SES Developer
- *                         Guide.</i>
- *                </p>
- *             </li>
- *             <li>
- *                 <p>For every message that you send, the total number of recipients (including
- *                     each recipient in the To:, CC: and BCC: fields) is counted against the maximum
- *                     number of emails you can send in a 24-hour period (your <i>sending
- *                         quota</i>). For more information about sending quotas in Amazon SES, see
- *                         <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/manage-sending-limits.html">Managing Your
- *                         Amazon SES Sending Limits</a> in the <i>Amazon SES Developer
- *                         Guide.</i>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, SendRawEmailCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SendRawEmailCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SendRawEmailCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendRawEmailCommandInput} for command's `input` shape.
- * @see {@link SendRawEmailCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var SendRawEmailCommand = /** @class */ (function (_super) {
-    __extends(SendRawEmailCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
-    function SendRawEmailCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
-        _this.input = input;
-        return _this;
-        // End section: command_constructor
-    }
-    /**
-     * @internal
-     */
-    SendRawEmailCommand.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 = "SendRawEmailCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
-            inputFilterSensitiveLog: SendRawEmailRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: SendRawEmailResponse.filterSensitiveLog,
-        };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SendRawEmailCommand.prototype.serialize = function (input, context) {
-        return serializeAws_querySendRawEmailCommand(input, context);
-    };
-    SendRawEmailCommand.prototype.deserialize = function (output, context) {
-        return deserializeAws_querySendRawEmailCommand(output, context);
-    };
-    return SendRawEmailCommand;
-}($Command));
-export { SendRawEmailCommand };
-//# sourceMappingURL=SendRawEmailCommand.js.map

package/dist/es/commands/SendRawEmailCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SendRawEmailCommand.js","sourceRoot":"","sources":["../../../commands/SendRawEmailCommand.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,EAAE,uCAAuC,EAAE,qCAAqC,EAAE,MAAM,wBAAwB,CAAC;AACxH,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAc7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4HG;AACH;IAAyC,uCAIxC;IACC,oCAAoC;IACpC,kCAAkC;IAElC,6BAAqB,KAA+B;QAApD;QACE,qCAAqC;QACrC,iBAAO,SAER;QAJoB,WAAK,GAAL,KAAK,CAA0B;;QAGlD,mCAAmC;IACrC,CAAC;IAED;;OAEG;IACH,+CAAiB,GAAjB,UACE,WAAmE,EACnE,aAAsC,EACtC,OAA8B;QAE9B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAE1F,IAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE/C,IAAA,MAAM,GAAK,aAAa,OAAlB,CAAmB;QACjC,IAAM,UAAU,GAAG,WAAW,CAAC;QAC/B,IAAM,WAAW,GAAG,qBAAqB,CAAC;QAC1C,IAAM,uBAAuB,GAA4B;YACvD,MAAM,QAAA;YACN,UAAU,YAAA;YACV,WAAW,aAAA;YACX,uBAAuB,EAAE,mBAAmB,CAAC,kBAAkB;YAC/D,wBAAwB,EAAE,oBAAoB,CAAC,kBAAkB;SAClE,CAAC;QACM,IAAA,cAAc,GAAK,aAAa,eAAlB,CAAmB;QACzC,OAAO,KAAK,CAAC,OAAO,CAClB,UAAC,OAAsC;YACrC,OAAA,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,OAAwB,EAAE,OAAO,IAAI,EAAE,CAAC;QAAtE,CAAsE,EACxE,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAEO,uCAAS,GAAjB,UAAkB,KAA+B,EAAE,OAAuB;QACxE,OAAO,qCAAqC,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC/D,CAAC;IAEO,yCAAW,GAAnB,UAAoB,MAAsB,EAAE,OAAuB;QACjE,OAAO,uCAAuC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAIH,0BAAC;AAAD,CAAC,AAtDD,CAAyC,QAAQ,GAsDhD"}

package/dist/es/commands/SendTemplatedEmailCommand.js

@@ -1,114 +0,0 @@
-import { __extends } from "tslib";
-import { SendTemplatedEmailRequest, SendTemplatedEmailResponse } from "../models/models_0";
-import { deserializeAws_querySendTemplatedEmailCommand, serializeAws_querySendTemplatedEmailCommand, } from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Composes an email message using an email template and immediately queues it for
- *             sending.</p>
- *         <p>In order to send email using the <code>SendTemplatedEmail</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>Calls to the <code>SendTemplatedEmail</code> operation may only include one
- *                         <code>Destination</code> parameter. A destination is a set of recipients who
- *                     will receive the same version of the email. The <code>Destination</code>
- *                     parameter can include up to 50 recipients, across the To:, CC: and BCC:
- *                     fields.</p>
- *             </li>
- *             <li>
- *                 <p>The <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>
- *          </ul>
- *         <important>
- *             <p>If your call to the <code>SendTemplatedEmail</code> operation includes all of the
- *                 required parameters, Amazon SES accepts it and returns a Message ID. However, if Amazon SES
- *                 can't render the email because the template contains errors, it doesn't send the
- *                 email. Additionally, because it already accepted the message, Amazon SES doesn't return a
- *                 message stating that it was unable to send the email.</p>
- *             <p>For these reasons, we highly recommend that you set up Amazon SES to send you
- *                 notifications when Rendering Failure events occur. For more information, see <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html">Sending
- *                     Personalized Email Using the Amazon SES API</a> in the <i>Amazon Simple Email Service
- *                     Developer Guide</i>.</p>
- *         </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, SendTemplatedEmailCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SendTemplatedEmailCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SendTemplatedEmailCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendTemplatedEmailCommandInput} for command's `input` shape.
- * @see {@link SendTemplatedEmailCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var SendTemplatedEmailCommand = /** @class */ (function (_super) {
-    __extends(SendTemplatedEmailCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
-    function SendTemplatedEmailCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
-        _this.input = input;
-        return _this;
-        // End section: command_constructor
-    }
-    /**
-     * @internal
-     */
-    SendTemplatedEmailCommand.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 = "SendTemplatedEmailCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
-            inputFilterSensitiveLog: SendTemplatedEmailRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: SendTemplatedEmailResponse.filterSensitiveLog,
-        };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    SendTemplatedEmailCommand.prototype.serialize = function (input, context) {
-        return serializeAws_querySendTemplatedEmailCommand(input, context);
-    };
-    SendTemplatedEmailCommand.prototype.deserialize = function (output, context) {
-        return deserializeAws_querySendTemplatedEmailCommand(output, context);
-    };
-    return SendTemplatedEmailCommand;
-}($Command));
-export { SendTemplatedEmailCommand };
-//# sourceMappingURL=SendTemplatedEmailCommand.js.map

package/dist/es/commands/SendTemplatedEmailCommand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SendTemplatedEmailCommand.js","sourceRoot":"","sources":["../../../commands/SendTemplatedEmailCommand.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAC3F,OAAO,EACL,6CAA6C,EAC7C,2CAA2C,GAC5C,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAc7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH;IAA+C,6CAI9C;IACC,oCAAoC;IACpC,kCAAkC;IAElC,mCAAqB,KAAqC;QAA1D;QACE,qCAAqC;QACrC,iBAAO,SAER;QAJoB,WAAK,GAAL,KAAK,CAAgC;;QAGxD,mCAAmC;IACrC,CAAC;IAED;;OAEG;IACH,qDAAiB,GAAjB,UACE,WAAmE,EACnE,aAAsC,EACtC,OAA8B;QAE9B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;QAE1F,IAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAE/C,IAAA,MAAM,GAAK,aAAa,OAAlB,CAAmB;QACjC,IAAM,UAAU,GAAG,WAAW,CAAC;QAC/B,IAAM,WAAW,GAAG,2BAA2B,CAAC;QAChD,IAAM,uBAAuB,GAA4B;YACvD,MAAM,QAAA;YACN,UAAU,YAAA;YACV,WAAW,aAAA;YACX,uBAAuB,EAAE,yBAAyB,CAAC,kBAAkB;YACrE,wBAAwB,EAAE,0BAA0B,CAAC,kBAAkB;SACxE,CAAC;QACM,IAAA,cAAc,GAAK,aAAa,eAAlB,CAAmB;QACzC,OAAO,KAAK,CAAC,OAAO,CAClB,UAAC,OAAsC;YACrC,OAAA,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,OAAwB,EAAE,OAAO,IAAI,EAAE,CAAC;QAAtE,CAAsE,EACxE,uBAAuB,CACxB,CAAC;IACJ,CAAC;IAEO,6CAAS,GAAjB,UAAkB,KAAqC,EAAE,OAAuB;QAC9E,OAAO,2CAA2C,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAEO,+CAAW,GAAnB,UAAoB,MAAsB,EAAE,OAAuB;QACjE,OAAO,6CAA6C,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxE,CAAC;IAIH,gCAAC;AAAD,CAAC,AAtDD,CAA+C,QAAQ,GAsDtD"}