@aws-sdk/client-ses 3.32.0 → 3.36.0

package/dist-types/ts3.4/commands/ListReceiptRuleSetsCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListReceiptRuleSetsRequest, ListReceiptRuleSetsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface ListReceiptRuleSetsCommandInput extends ListReceiptRuleSetsRequest {
+}
+export interface ListReceiptRuleSetsCommandOutput extends ListReceiptRuleSetsResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class ListReceiptRuleSetsCommand extends $Command<ListReceiptRuleSetsCommandInput, ListReceiptRuleSetsCommandOutput, SESClientResolvedConfig> {
+    readonly input: ListReceiptRuleSetsCommandInput;
+    constructor(input: ListReceiptRuleSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListReceiptRuleSetsCommandInput, ListReceiptRuleSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListTemplatesCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListTemplatesRequest, ListTemplatesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface ListTemplatesCommandInput extends ListTemplatesRequest {
+}
+export interface ListTemplatesCommandOutput extends ListTemplatesResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class ListTemplatesCommand extends $Command<ListTemplatesCommandInput, ListTemplatesCommandOutput, SESClientResolvedConfig> {
+    readonly input: ListTemplatesCommandInput;
+    constructor(input: ListTemplatesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTemplatesCommandInput, ListTemplatesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListVerifiedEmailAddressesCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListVerifiedEmailAddressesResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface ListVerifiedEmailAddressesCommandInput {
+}
+export interface ListVerifiedEmailAddressesCommandOutput extends ListVerifiedEmailAddressesResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class ListVerifiedEmailAddressesCommand extends $Command<ListVerifiedEmailAddressesCommandInput, ListVerifiedEmailAddressesCommandOutput, SESClientResolvedConfig> {
+    readonly input: ListVerifiedEmailAddressesCommandInput;
+    constructor(input: ListVerifiedEmailAddressesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListVerifiedEmailAddressesCommandInput, ListVerifiedEmailAddressesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutConfigurationSetDeliveryOptionsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutConfigurationSetDeliveryOptionsRequest, PutConfigurationSetDeliveryOptionsResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface PutConfigurationSetDeliveryOptionsCommandInput extends PutConfigurationSetDeliveryOptionsRequest {
+}
+export interface PutConfigurationSetDeliveryOptionsCommandOutput extends PutConfigurationSetDeliveryOptionsResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class PutConfigurationSetDeliveryOptionsCommand extends $Command<PutConfigurationSetDeliveryOptionsCommandInput, PutConfigurationSetDeliveryOptionsCommandOutput, SESClientResolvedConfig> {
+    readonly input: PutConfigurationSetDeliveryOptionsCommandInput;
+    constructor(input: PutConfigurationSetDeliveryOptionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutConfigurationSetDeliveryOptionsCommandInput, PutConfigurationSetDeliveryOptionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/PutIdentityPolicyCommand.d.ts

@@ -0,0 +1,45 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutIdentityPolicyRequest, PutIdentityPolicyResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface PutIdentityPolicyCommandInput extends PutIdentityPolicyRequest {
+}
+export interface PutIdentityPolicyCommandOutput extends PutIdentityPolicyResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class PutIdentityPolicyCommand extends $Command<PutIdentityPolicyCommandInput, PutIdentityPolicyCommandOutput, SESClientResolvedConfig> {
+    readonly input: PutIdentityPolicyCommandInput;
+    constructor(input: PutIdentityPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutIdentityPolicyCommandInput, PutIdentityPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ReorderReceiptRuleSetCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ReorderReceiptRuleSetRequest, ReorderReceiptRuleSetResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface ReorderReceiptRuleSetCommandInput extends ReorderReceiptRuleSetRequest {
+}
+export interface ReorderReceiptRuleSetCommandOutput extends ReorderReceiptRuleSetResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class ReorderReceiptRuleSetCommand extends $Command<ReorderReceiptRuleSetCommandInput, ReorderReceiptRuleSetCommandOutput, SESClientResolvedConfig> {
+    readonly input: ReorderReceiptRuleSetCommandInput;
+    constructor(input: ReorderReceiptRuleSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReorderReceiptRuleSetCommandInput, ReorderReceiptRuleSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SendBounceCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SendBounceRequest, SendBounceResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface SendBounceCommandInput extends SendBounceRequest {
+}
+export interface SendBounceCommandOutput extends SendBounceResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class SendBounceCommand extends $Command<SendBounceCommandInput, SendBounceCommandOutput, SESClientResolvedConfig> {
+    readonly input: SendBounceCommandInput;
+    constructor(input: SendBounceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendBounceCommandInput, SendBounceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SendBulkTemplatedEmailCommand.d.ts

@@ -0,0 +1,77 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SendBulkTemplatedEmailRequest, SendBulkTemplatedEmailResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface SendBulkTemplatedEmailCommandInput extends SendBulkTemplatedEmailRequest {
+}
+export interface SendBulkTemplatedEmailCommandOutput extends SendBulkTemplatedEmailResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class SendBulkTemplatedEmailCommand extends $Command<SendBulkTemplatedEmailCommandInput, SendBulkTemplatedEmailCommandOutput, SESClientResolvedConfig> {
+    readonly input: SendBulkTemplatedEmailCommandInput;
+    constructor(input: SendBulkTemplatedEmailCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendBulkTemplatedEmailCommandInput, SendBulkTemplatedEmailCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SendCustomVerificationEmailCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SendCustomVerificationEmailRequest, SendCustomVerificationEmailResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface SendCustomVerificationEmailCommandInput extends SendCustomVerificationEmailRequest {
+}
+export interface SendCustomVerificationEmailCommandOutput extends SendCustomVerificationEmailResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class SendCustomVerificationEmailCommand extends $Command<SendCustomVerificationEmailCommandInput, SendCustomVerificationEmailCommandOutput, SESClientResolvedConfig> {
+    readonly input: SendCustomVerificationEmailCommandInput;
+    constructor(input: SendCustomVerificationEmailCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendCustomVerificationEmailCommandInput, SendCustomVerificationEmailCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SendEmailCommand.d.ts

@@ -0,0 +1,79 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SendEmailRequest, SendEmailResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface SendEmailCommandInput extends SendEmailRequest {
+}
+export interface SendEmailCommandOutput extends SendEmailResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class SendEmailCommand extends $Command<SendEmailCommandInput, SendEmailCommandOutput, SESClientResolvedConfig> {
+    readonly input: SendEmailCommandInput;
+    constructor(input: SendEmailCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendEmailCommandInput, SendEmailCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SendRawEmailCommand.d.ts

@@ -0,0 +1,143 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SendRawEmailRequest, SendRawEmailResponse } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, SESClientResolvedConfig } from "../SESClient";
+export interface SendRawEmailCommandInput extends SendRawEmailRequest {
+}
+export interface SendRawEmailCommandOutput extends SendRawEmailResponse, __MetadataBearer {
+}
+/**
+ * <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.
+ *
+ */
+export declare class SendRawEmailCommand extends $Command<SendRawEmailCommandInput, SendRawEmailCommandOutput, SESClientResolvedConfig> {
+    readonly input: SendRawEmailCommandInput;
+    constructor(input: SendRawEmailCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendRawEmailCommandInput, SendRawEmailCommandOutput>;
+    private serialize;
+    private deserialize;
+}