@aws-sdk/client-ses 3.32.0 → 3.36.0

package/commands/PutIdentityPolicyCommand.ts

@@ -1,104 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { PutIdentityPolicyRequest, PutIdentityPolicyResponse } from "../models/models_0";
-import {
-  deserializeAws_queryPutIdentityPolicyCommand,
-  serializeAws_queryPutIdentityPolicyCommand,
-} 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 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 class PutIdentityPolicyCommand extends $Command<
-  PutIdentityPolicyCommandInput,
-  PutIdentityPolicyCommandOutput,
-  SESClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: PutIdentityPolicyCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<PutIdentityPolicyCommandInput, PutIdentityPolicyCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "PutIdentityPolicyCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: PutIdentityPolicyRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: PutIdentityPolicyResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: PutIdentityPolicyCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_queryPutIdentityPolicyCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<PutIdentityPolicyCommandOutput> {
-    return deserializeAws_queryPutIdentityPolicyCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/ReorderReceiptRuleSetCommand.ts

@@ -1,101 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { ReorderReceiptRuleSetRequest, ReorderReceiptRuleSetResponse } from "../models/models_0";
-import {
-  deserializeAws_queryReorderReceiptRuleSetCommand,
-  serializeAws_queryReorderReceiptRuleSetCommand,
-} 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 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 class ReorderReceiptRuleSetCommand extends $Command<
-  ReorderReceiptRuleSetCommandInput,
-  ReorderReceiptRuleSetCommandOutput,
-  SESClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: ReorderReceiptRuleSetCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<ReorderReceiptRuleSetCommandInput, ReorderReceiptRuleSetCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "ReorderReceiptRuleSetCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: ReorderReceiptRuleSetRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: ReorderReceiptRuleSetResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: ReorderReceiptRuleSetCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_queryReorderReceiptRuleSetCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<ReorderReceiptRuleSetCommandOutput> {
-    return deserializeAws_queryReorderReceiptRuleSetCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/SendBounceCommand.ts

@@ -1,99 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SendBounceRequest, SendBounceResponse } from "../models/models_0";
-import { deserializeAws_querySendBounceCommand, serializeAws_querySendBounceCommand } 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 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 class SendBounceCommand extends $Command<
-  SendBounceCommandInput,
-  SendBounceCommandOutput,
-  SESClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SendBounceCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SendBounceCommandInput, SendBounceCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "SendBounceCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SendBounceRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: SendBounceResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SendBounceCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySendBounceCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<SendBounceCommandOutput> {
-    return deserializeAws_querySendBounceCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/SendBulkTemplatedEmailCommand.ts

@@ -1,136 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SendBulkTemplatedEmailRequest, SendBulkTemplatedEmailResponse } from "../models/models_0";
-import {
-  deserializeAws_querySendBulkTemplatedEmailCommand,
-  serializeAws_querySendBulkTemplatedEmailCommand,
-} 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 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 class SendBulkTemplatedEmailCommand extends $Command<
-  SendBulkTemplatedEmailCommandInput,
-  SendBulkTemplatedEmailCommandOutput,
-  SESClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SendBulkTemplatedEmailCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SendBulkTemplatedEmailCommandInput, SendBulkTemplatedEmailCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "SendBulkTemplatedEmailCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SendBulkTemplatedEmailRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: SendBulkTemplatedEmailResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SendBulkTemplatedEmailCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySendBulkTemplatedEmailCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<SendBulkTemplatedEmailCommandOutput> {
-    return deserializeAws_querySendBulkTemplatedEmailCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/SendCustomVerificationEmailCommand.ts

@@ -1,107 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SendCustomVerificationEmailRequest, SendCustomVerificationEmailResponse } from "../models/models_0";
-import {
-  deserializeAws_querySendCustomVerificationEmailCommand,
-  serializeAws_querySendCustomVerificationEmailCommand,
-} 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 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 class SendCustomVerificationEmailCommand extends $Command<
-  SendCustomVerificationEmailCommandInput,
-  SendCustomVerificationEmailCommandOutput,
-  SESClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SendCustomVerificationEmailCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SendCustomVerificationEmailCommandInput, SendCustomVerificationEmailCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "SendCustomVerificationEmailCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SendCustomVerificationEmailRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: SendCustomVerificationEmailResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SendCustomVerificationEmailCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySendCustomVerificationEmailCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<SendCustomVerificationEmailCommandOutput> {
-    return deserializeAws_querySendCustomVerificationEmailCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/SendEmailCommand.ts

@@ -1,131 +0,0 @@
-import { SESClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SESClient";
-import { SendEmailRequest, SendEmailResponse } from "../models/models_0";
-import { deserializeAws_querySendEmailCommand, serializeAws_querySendEmailCommand } 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 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 class SendEmailCommand extends $Command<SendEmailCommandInput, SendEmailCommandOutput, SESClientResolvedConfig> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: SendEmailCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: SESClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<SendEmailCommandInput, SendEmailCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "SESClient";
-    const commandName = "SendEmailCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: SendEmailRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: SendEmailResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: SendEmailCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_querySendEmailCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<SendEmailCommandOutput> {
-    return deserializeAws_querySendEmailCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}