@aws-sdk/client-ses 3.32.0 → 3.36.0

package/dist/types/commands/SendTemplatedEmailCommand.d.ts

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

package/dist/types/commands/SetActiveReceiptRuleSetCommand.d.ts

@@ -1,41 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SetActiveReceiptRuleSetRequest, SetActiveReceiptRuleSetResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SetActiveReceiptRuleSetCommandInput extends SetActiveReceiptRuleSetRequest {
-}
-export interface SetActiveReceiptRuleSetCommandOutput extends SetActiveReceiptRuleSetResponse, __MetadataBearer {
-}
-/**
- * <p>Sets the specified receipt rule set as the active receipt rule set.</p>
- *         <note>
- *             <p>To disable your email-receiving through Amazon SES completely, you can call this API
- *                 with RuleSetName set to null.</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, SetActiveReceiptRuleSetCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SetActiveReceiptRuleSetCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SetActiveReceiptRuleSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetActiveReceiptRuleSetCommandInput} for command's `input` shape.
- * @see {@link SetActiveReceiptRuleSetCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SetActiveReceiptRuleSetCommand extends $Command<SetActiveReceiptRuleSetCommandInput, SetActiveReceiptRuleSetCommandOutput, SESClientResolvedConfig> {
-    readonly input: SetActiveReceiptRuleSetCommandInput;
-    constructor(input: SetActiveReceiptRuleSetCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetActiveReceiptRuleSetCommandInput, SetActiveReceiptRuleSetCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/SetIdentityDkimEnabledCommand.d.ts

@@ -1,47 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SetIdentityDkimEnabledRequest, SetIdentityDkimEnabledResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SetIdentityDkimEnabledCommandInput extends SetIdentityDkimEnabledRequest {
-}
-export interface SetIdentityDkimEnabledCommandOutput extends SetIdentityDkimEnabledResponse, __MetadataBearer {
-}
-/**
- * <p>Enables or disables Easy DKIM signing of email sent from an identity. If Easy DKIM
- *             signing is enabled for a domain, then Amazon SES uses DKIM to sign all email that it sends
- *             from addresses on that domain. If Easy DKIM signing is enabled for an email address,
- *             then Amazon SES uses DKIM to sign all email it sends from that address.</p>
- *         <note>
- *             <p>For email addresses (for example, <code>user@example.com</code>), you can only
- *                 enable DKIM signing if the corresponding domain (in this case,
- *                     <code>example.com</code>) has been set up to use Easy DKIM.</p>
- *         </note>
- *         <p>You can enable DKIM signing for an identity at any time after you start the
- *             verification process for the identity, even if the verification process isn't complete. </p>
- *         <p>You can execute this operation no more than once per second.</p>
- *         <p>For more information about Easy DKIM signing, go to the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">Amazon SES Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, SetIdentityDkimEnabledCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SetIdentityDkimEnabledCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SetIdentityDkimEnabledCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetIdentityDkimEnabledCommandInput} for command's `input` shape.
- * @see {@link SetIdentityDkimEnabledCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SetIdentityDkimEnabledCommand extends $Command<SetIdentityDkimEnabledCommandInput, SetIdentityDkimEnabledCommandOutput, SESClientResolvedConfig> {
-    readonly input: SetIdentityDkimEnabledCommandInput;
-    constructor(input: SetIdentityDkimEnabledCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetIdentityDkimEnabledCommandInput, SetIdentityDkimEnabledCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/SetIdentityFeedbackForwardingEnabledCommand.d.ts

@@ -1,45 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SetIdentityFeedbackForwardingEnabledRequest, SetIdentityFeedbackForwardingEnabledResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SetIdentityFeedbackForwardingEnabledCommandInput extends SetIdentityFeedbackForwardingEnabledRequest {
-}
-export interface SetIdentityFeedbackForwardingEnabledCommandOutput extends SetIdentityFeedbackForwardingEnabledResponse, __MetadataBearer {
-}
-/**
- * <p>Given an identity (an email address or a domain), enables or disables whether Amazon SES
- *             forwards bounce and complaint notifications as email. Feedback forwarding can only be
- *             disabled when Amazon Simple Notification Service (Amazon SNS) topics are specified for both bounces and
- *             complaints.</p>
- *         <note>
- *             <p>Feedback forwarding does not apply to delivery notifications. Delivery
- *                 notifications are only available through Amazon SNS.</p>
- *         </note>
- *         <p>You can execute this operation no more than once per second.</p>
- *         <p>For more information about using notifications with Amazon SES, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/notifications.html">Amazon SES
- *                 Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, SetIdentityFeedbackForwardingEnabledCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SetIdentityFeedbackForwardingEnabledCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SetIdentityFeedbackForwardingEnabledCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetIdentityFeedbackForwardingEnabledCommandInput} for command's `input` shape.
- * @see {@link SetIdentityFeedbackForwardingEnabledCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SetIdentityFeedbackForwardingEnabledCommand extends $Command<SetIdentityFeedbackForwardingEnabledCommandInput, SetIdentityFeedbackForwardingEnabledCommandOutput, SESClientResolvedConfig> {
-    readonly input: SetIdentityFeedbackForwardingEnabledCommandInput;
-    constructor(input: SetIdentityFeedbackForwardingEnabledCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetIdentityFeedbackForwardingEnabledCommandInput, SetIdentityFeedbackForwardingEnabledCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/SetIdentityHeadersInNotificationsEnabledCommand.d.ts

@@ -1,40 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SetIdentityHeadersInNotificationsEnabledRequest, SetIdentityHeadersInNotificationsEnabledResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SetIdentityHeadersInNotificationsEnabledCommandInput extends SetIdentityHeadersInNotificationsEnabledRequest {
-}
-export interface SetIdentityHeadersInNotificationsEnabledCommandOutput extends SetIdentityHeadersInNotificationsEnabledResponse, __MetadataBearer {
-}
-/**
- * <p>Given an identity (an email address or a domain), sets whether Amazon SES includes the
- *             original email headers in the Amazon Simple Notification Service (Amazon SNS) notifications of a specified
- *             type.</p>
- *         <p>You can execute this operation no more than once per second.</p>
- *         <p>For more information about using notifications with Amazon SES, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/notifications.html">Amazon SES
- *                 Developer Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, SetIdentityHeadersInNotificationsEnabledCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SetIdentityHeadersInNotificationsEnabledCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SetIdentityHeadersInNotificationsEnabledCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetIdentityHeadersInNotificationsEnabledCommandInput} for command's `input` shape.
- * @see {@link SetIdentityHeadersInNotificationsEnabledCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SetIdentityHeadersInNotificationsEnabledCommand extends $Command<SetIdentityHeadersInNotificationsEnabledCommandInput, SetIdentityHeadersInNotificationsEnabledCommandOutput, SESClientResolvedConfig> {
-    readonly input: SetIdentityHeadersInNotificationsEnabledCommandInput;
-    constructor(input: SetIdentityHeadersInNotificationsEnabledCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetIdentityHeadersInNotificationsEnabledCommandInput, SetIdentityHeadersInNotificationsEnabledCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/SetIdentityMailFromDomainCommand.d.ts

@@ -1,44 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SetIdentityMailFromDomainRequest, SetIdentityMailFromDomainResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SetIdentityMailFromDomainCommandInput extends SetIdentityMailFromDomainRequest {
-}
-export interface SetIdentityMailFromDomainCommandOutput extends SetIdentityMailFromDomainResponse, __MetadataBearer {
-}
-/**
- * <p>Enables or disables the custom MAIL FROM domain setup for a verified identity (an
- *             email address or a domain).</p>
- *         <important>
- *             <p>To send emails using the specified MAIL FROM domain, you must add an MX record to
- *                 your MAIL FROM domain's DNS settings. If you want your emails to pass Sender Policy
- *                 Framework (SPF) checks, you must also add or update an SPF record. For more
- *                 information, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/mail-from-set.html">Amazon SES Developer
- *                 Guide</a>.</p>
- *         </important>
- *         <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, SetIdentityMailFromDomainCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SetIdentityMailFromDomainCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SetIdentityMailFromDomainCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetIdentityMailFromDomainCommandInput} for command's `input` shape.
- * @see {@link SetIdentityMailFromDomainCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SetIdentityMailFromDomainCommand extends $Command<SetIdentityMailFromDomainCommandInput, SetIdentityMailFromDomainCommandOutput, SESClientResolvedConfig> {
-    readonly input: SetIdentityMailFromDomainCommandInput;
-    constructor(input: SetIdentityMailFromDomainCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetIdentityMailFromDomainCommandInput, SetIdentityMailFromDomainCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/SetIdentityNotificationTopicCommand.d.ts

@@ -1,43 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SetIdentityNotificationTopicRequest, SetIdentityNotificationTopicResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SetIdentityNotificationTopicCommandInput extends SetIdentityNotificationTopicRequest {
-}
-export interface SetIdentityNotificationTopicCommandOutput extends SetIdentityNotificationTopicResponse, __MetadataBearer {
-}
-/**
- * <p>Sets an Amazon Simple Notification Service (Amazon SNS) topic to use when delivering notifications. When you use
- *             this operation, you specify a verified identity, such as an email address or domain.
- *             When you send an email that uses the chosen identity in the Source field, Amazon SES sends
- *             notifications to the topic you specified. You can send bounce, complaint, or delivery
- *             notifications (or any combination of the three) to the Amazon SNS topic that you
- *             specify.</p>
- *         <p>You can execute this operation no more than once per second.</p>
- *         <p>For more information about feedback notification, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/notifications.html">Amazon SES Developer
- *             Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, SetIdentityNotificationTopicCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SetIdentityNotificationTopicCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SetIdentityNotificationTopicCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetIdentityNotificationTopicCommandInput} for command's `input` shape.
- * @see {@link SetIdentityNotificationTopicCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SetIdentityNotificationTopicCommand extends $Command<SetIdentityNotificationTopicCommandInput, SetIdentityNotificationTopicCommandOutput, SESClientResolvedConfig> {
-    readonly input: SetIdentityNotificationTopicCommandInput;
-    constructor(input: SetIdentityNotificationTopicCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetIdentityNotificationTopicCommandInput, SetIdentityNotificationTopicCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/SetReceiptRulePositionCommand.d.ts

@@ -1,38 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SetReceiptRulePositionRequest, SetReceiptRulePositionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SetReceiptRulePositionCommandInput extends SetReceiptRulePositionRequest {
-}
-export interface SetReceiptRulePositionCommandOutput extends SetReceiptRulePositionResponse, __MetadataBearer {
-}
-/**
- * <p>Sets the position of the specified receipt rule in the receipt rule set.</p>
- *         <p>For information about managing receipt rules, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/receiving-email-managing-receipt-rules.html">Amazon SES
- *                 Developer Guide</a>.</p>
- *         <p>You can execute this operation no more than once per second.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, SetReceiptRulePositionCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, SetReceiptRulePositionCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new SetReceiptRulePositionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetReceiptRulePositionCommandInput} for command's `input` shape.
- * @see {@link SetReceiptRulePositionCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SetReceiptRulePositionCommand extends $Command<SetReceiptRulePositionCommandInput, SetReceiptRulePositionCommandOutput, SESClientResolvedConfig> {
-    readonly input: SetReceiptRulePositionCommandInput;
-    constructor(input: SetReceiptRulePositionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetReceiptRulePositionCommandInput, SetReceiptRulePositionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/TestRenderTemplateCommand.d.ts

@@ -1,37 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { TestRenderTemplateRequest, TestRenderTemplateResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface TestRenderTemplateCommandInput extends TestRenderTemplateRequest {
-}
-export interface TestRenderTemplateCommandOutput extends TestRenderTemplateResponse, __MetadataBearer {
-}
-/**
- * <p>Creates a preview of the MIME content of an email when provided with a template and a
- *             set of replacement data.</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, TestRenderTemplateCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, TestRenderTemplateCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new TestRenderTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TestRenderTemplateCommandInput} for command's `input` shape.
- * @see {@link TestRenderTemplateCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class TestRenderTemplateCommand extends $Command<TestRenderTemplateCommandInput, TestRenderTemplateCommandOutput, SESClientResolvedConfig> {
-    readonly input: TestRenderTemplateCommandInput;
-    constructor(input: TestRenderTemplateCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestRenderTemplateCommandInput, TestRenderTemplateCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/UpdateAccountSendingEnabledCommand.d.ts

@@ -1,40 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { UpdateAccountSendingEnabledRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateAccountSendingEnabledCommandInput extends UpdateAccountSendingEnabledRequest {
-}
-export interface UpdateAccountSendingEnabledCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Enables or disables email sending across your entire Amazon SES account in the current
- *             AWS Region. You can use this operation in conjunction with Amazon CloudWatch alarms to
- *             temporarily pause email sending across your Amazon SES account in a given AWS Region when
- *             reputation metrics (such as your bounce or complaint rates) reach certain
- *             thresholds.</p>
- *         <p>You can execute this operation no more than once per second.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, UpdateAccountSendingEnabledCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, UpdateAccountSendingEnabledCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new UpdateAccountSendingEnabledCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAccountSendingEnabledCommandInput} for command's `input` shape.
- * @see {@link UpdateAccountSendingEnabledCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateAccountSendingEnabledCommand extends $Command<UpdateAccountSendingEnabledCommandInput, UpdateAccountSendingEnabledCommandOutput, SESClientResolvedConfig> {
-    readonly input: UpdateAccountSendingEnabledCommandInput;
-    constructor(input: UpdateAccountSendingEnabledCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAccountSendingEnabledCommandInput, UpdateAccountSendingEnabledCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/UpdateConfigurationSetEventDestinationCommand.d.ts

@@ -1,46 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { UpdateConfigurationSetEventDestinationRequest, UpdateConfigurationSetEventDestinationResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateConfigurationSetEventDestinationCommandInput extends UpdateConfigurationSetEventDestinationRequest {
-}
-export interface UpdateConfigurationSetEventDestinationCommandOutput extends UpdateConfigurationSetEventDestinationResponse, __MetadataBearer {
-}
-/**
- * <p>Updates the event destination of a configuration set. Event destinations are
- *             associated with configuration sets, which enable you to publish email sending events to
- *             Amazon CloudWatch, Amazon Kinesis Firehose, or Amazon Simple Notification Service (Amazon SNS). For information about using configuration sets,
- *             see <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/monitor-sending-activity.html">Monitoring Your Amazon SES
- *                 Sending Activity</a> in the <i>Amazon SES Developer Guide.</i>
- *          </p>
- *         <note>
- *             <p>When you create or update an event destination, you must provide one, and only
- *                 one, destination. The destination can be Amazon CloudWatch, Amazon Kinesis Firehose, or Amazon Simple Notification Service
- *                 (Amazon SNS).</p>
- *         </note>
- *         <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, UpdateConfigurationSetEventDestinationCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, UpdateConfigurationSetEventDestinationCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new UpdateConfigurationSetEventDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConfigurationSetEventDestinationCommandInput} for command's `input` shape.
- * @see {@link UpdateConfigurationSetEventDestinationCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateConfigurationSetEventDestinationCommand extends $Command<UpdateConfigurationSetEventDestinationCommandInput, UpdateConfigurationSetEventDestinationCommandOutput, SESClientResolvedConfig> {
-    readonly input: UpdateConfigurationSetEventDestinationCommandInput;
-    constructor(input: UpdateConfigurationSetEventDestinationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConfigurationSetEventDestinationCommandInput, UpdateConfigurationSetEventDestinationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/UpdateConfigurationSetReputationMetricsEnabledCommand.d.ts

@@ -1,39 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { UpdateConfigurationSetReputationMetricsEnabledRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateConfigurationSetReputationMetricsEnabledCommandInput extends UpdateConfigurationSetReputationMetricsEnabledRequest {
-}
-export interface UpdateConfigurationSetReputationMetricsEnabledCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Enables or disables the publishing of reputation metrics for emails sent using a
- *             specific configuration set in a given AWS Region. Reputation metrics include bounce
- *             and complaint rates. These metrics are published to Amazon CloudWatch. By using CloudWatch, you can
- *             create alarms when bounce or complaint rates exceed certain thresholds.</p>
- *         <p>You can execute this operation no more than once per second.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, UpdateConfigurationSetReputationMetricsEnabledCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, UpdateConfigurationSetReputationMetricsEnabledCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new UpdateConfigurationSetReputationMetricsEnabledCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConfigurationSetReputationMetricsEnabledCommandInput} for command's `input` shape.
- * @see {@link UpdateConfigurationSetReputationMetricsEnabledCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateConfigurationSetReputationMetricsEnabledCommand extends $Command<UpdateConfigurationSetReputationMetricsEnabledCommandInput, UpdateConfigurationSetReputationMetricsEnabledCommandOutput, SESClientResolvedConfig> {
-    readonly input: UpdateConfigurationSetReputationMetricsEnabledCommandInput;
-    constructor(input: UpdateConfigurationSetReputationMetricsEnabledCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConfigurationSetReputationMetricsEnabledCommandInput, UpdateConfigurationSetReputationMetricsEnabledCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/commands/UpdateConfigurationSetSendingEnabledCommand.d.ts

@@ -1,40 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { UpdateConfigurationSetSendingEnabledRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateConfigurationSetSendingEnabledCommandInput extends UpdateConfigurationSetSendingEnabledRequest {
-}
-export interface UpdateConfigurationSetSendingEnabledCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Enables or disables email sending for messages sent using a specific configuration set
- *             in a given AWS Region. You can use this operation in conjunction with Amazon CloudWatch alarms
- *             to temporarily pause email sending for a configuration set when the reputation metrics
- *             for that configuration set (such as your bounce on complaint rate) exceed certain
- *             thresholds.</p>
- *         <p>You can execute this operation no more than once per second.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, UpdateConfigurationSetSendingEnabledCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, UpdateConfigurationSetSendingEnabledCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new UpdateConfigurationSetSendingEnabledCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConfigurationSetSendingEnabledCommandInput} for command's `input` shape.
- * @see {@link UpdateConfigurationSetSendingEnabledCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateConfigurationSetSendingEnabledCommand extends $Command<UpdateConfigurationSetSendingEnabledCommandInput, UpdateConfigurationSetSendingEnabledCommandOutput, SESClientResolvedConfig> {
-    readonly input: UpdateConfigurationSetSendingEnabledCommandInput;
-    constructor(input: UpdateConfigurationSetSendingEnabledCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConfigurationSetSendingEnabledCommandInput, UpdateConfigurationSetSendingEnabledCommandOutput>;
-    private serialize;
-    private deserialize;
-}