@aws-sdk/client-ses 3.32.0 → 3.36.0

package/commands/SendRawEmailCommand.ts

@@ -1,199 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SendRawEmailRequest, SendRawEmailResponse } from "../models/models_0";
-import { deserializeAws_querySendRawEmailCommand, serializeAws_querySendRawEmailCommand } from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-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 class SendRawEmailCommand extends $Command<
-  SendRawEmailCommandInput,
-  SendRawEmailCommandOutput,
-  SESClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SendRawEmailCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SendRawEmailCommandInput, SendRawEmailCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "SendRawEmailCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SendRawEmailRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: SendRawEmailResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SendRawEmailCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySendRawEmailCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<SendRawEmailCommandOutput> {
-    return deserializeAws_querySendRawEmailCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/SendTemplatedEmailCommand.ts

@@ -1,143 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SendTemplatedEmailRequest, SendTemplatedEmailResponse } from "../models/models_0";
-import {
-  deserializeAws_querySendTemplatedEmailCommand,
-  serializeAws_querySendTemplatedEmailCommand,
-} from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} 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 class SendTemplatedEmailCommand extends $Command<
-  SendTemplatedEmailCommandInput,
-  SendTemplatedEmailCommandOutput,
-  SESClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SendTemplatedEmailCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SendTemplatedEmailCommandInput, SendTemplatedEmailCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "SendTemplatedEmailCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SendTemplatedEmailRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: SendTemplatedEmailResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SendTemplatedEmailCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySendTemplatedEmailCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<SendTemplatedEmailCommandOutput> {
-    return deserializeAws_querySendTemplatedEmailCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/SetActiveReceiptRuleSetCommand.ts

@@ -1,100 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SetActiveReceiptRuleSetRequest, SetActiveReceiptRuleSetResponse } from "../models/models_0";
-import {
-  deserializeAws_querySetActiveReceiptRuleSetCommand,
-  serializeAws_querySetActiveReceiptRuleSetCommand,
-} from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} 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 class SetActiveReceiptRuleSetCommand extends $Command<
-  SetActiveReceiptRuleSetCommandInput,
-  SetActiveReceiptRuleSetCommandOutput,
-  SESClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SetActiveReceiptRuleSetCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SetActiveReceiptRuleSetCommandInput, SetActiveReceiptRuleSetCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "SetActiveReceiptRuleSetCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SetActiveReceiptRuleSetRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: SetActiveReceiptRuleSetResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SetActiveReceiptRuleSetCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySetActiveReceiptRuleSetCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<SetActiveReceiptRuleSetCommandOutput> {
-    return deserializeAws_querySetActiveReceiptRuleSetCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/SetIdentityDkimEnabledCommand.ts

@@ -1,106 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SetIdentityDkimEnabledRequest, SetIdentityDkimEnabledResponse } from "../models/models_0";
-import {
-  deserializeAws_querySetIdentityDkimEnabledCommand,
-  serializeAws_querySetIdentityDkimEnabledCommand,
-} from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} 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 class SetIdentityDkimEnabledCommand extends $Command<
-  SetIdentityDkimEnabledCommandInput,
-  SetIdentityDkimEnabledCommandOutput,
-  SESClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SetIdentityDkimEnabledCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SetIdentityDkimEnabledCommandInput, SetIdentityDkimEnabledCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "SetIdentityDkimEnabledCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SetIdentityDkimEnabledRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: SetIdentityDkimEnabledResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SetIdentityDkimEnabledCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySetIdentityDkimEnabledCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<SetIdentityDkimEnabledCommandOutput> {
-    return deserializeAws_querySetIdentityDkimEnabledCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/SetIdentityFeedbackForwardingEnabledCommand.ts

@@ -1,115 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import {
-  SetIdentityFeedbackForwardingEnabledRequest,
-  SetIdentityFeedbackForwardingEnabledResponse,
-} from "../models/models_0";
-import {
-  deserializeAws_querySetIdentityFeedbackForwardingEnabledCommand,
-  serializeAws_querySetIdentityFeedbackForwardingEnabledCommand,
-} from "../protocols/Aws_query";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} 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 class SetIdentityFeedbackForwardingEnabledCommand extends $Command<
-  SetIdentityFeedbackForwardingEnabledCommandInput,
-  SetIdentityFeedbackForwardingEnabledCommandOutput,
-  SESClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SetIdentityFeedbackForwardingEnabledCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SetIdentityFeedbackForwardingEnabledCommandInput, SetIdentityFeedbackForwardingEnabledCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "SetIdentityFeedbackForwardingEnabledCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SetIdentityFeedbackForwardingEnabledRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: SetIdentityFeedbackForwardingEnabledResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: SetIdentityFeedbackForwardingEnabledCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_querySetIdentityFeedbackForwardingEnabledCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<SetIdentityFeedbackForwardingEnabledCommandOutput> {
-    return deserializeAws_querySetIdentityFeedbackForwardingEnabledCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}