@aws-sdk/client-ses 3.36.0 → 3.39.0

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

@@ -6,38 +6,11 @@ export interface SetIdentityMailFromDomainCommandInput extends SetIdentityMailFr
 }
 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/ts3.4/commands/SetIdentityNotificationTopicCommand.d.ts

@@ -6,37 +6,11 @@ export interface SetIdentityNotificationTopicCommandInput extends SetIdentityNot
 }
 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/ts3.4/commands/SetReceiptRulePositionCommand.d.ts

@@ -6,32 +6,11 @@ export interface SetReceiptRulePositionCommandInput extends SetReceiptRulePositi
 }
 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/ts3.4/commands/TestRenderTemplateCommand.d.ts

@@ -6,31 +6,11 @@ export interface TestRenderTemplateCommandInput extends TestRenderTemplateReques
 }
 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/ts3.4/commands/UpdateAccountSendingEnabledCommand.d.ts

@@ -6,34 +6,11 @@ export interface UpdateAccountSendingEnabledCommandInput extends UpdateAccountSe
 }
 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/ts3.4/commands/UpdateConfigurationSetEventDestinationCommand.d.ts

@@ -6,40 +6,11 @@ export interface UpdateConfigurationSetEventDestinationCommandInput extends Upda
 }
 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/ts3.4/commands/UpdateConfigurationSetReputationMetricsEnabledCommand.d.ts

@@ -6,33 +6,11 @@ export interface UpdateConfigurationSetReputationMetricsEnabledCommandInput exte
 }
 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/ts3.4/commands/UpdateConfigurationSetSendingEnabledCommand.d.ts

@@ -6,34 +6,11 @@ export interface UpdateConfigurationSetSendingEnabledCommandInput extends Update
 }
 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;

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

@@ -6,33 +6,11 @@ export interface UpdateConfigurationSetTrackingOptionsCommandInput extends Updat
 }
 export interface UpdateConfigurationSetTrackingOptionsCommandOutput extends UpdateConfigurationSetTrackingOptionsResponse, __MetadataBearer {
 }
-/**
- * <p>Modifies an association between a configuration set and a custom domain for open and
- *             click event tracking. </p>
- *         <p>By default, images and links used for tracking open and click events are hosted on
- *             domains operated by Amazon SES. You can configure a subdomain of your own to handle these
- *             events. For information about using custom domains, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/configure-custom-open-click-domains.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, UpdateConfigurationSetTrackingOptionsCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, UpdateConfigurationSetTrackingOptionsCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new UpdateConfigurationSetTrackingOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConfigurationSetTrackingOptionsCommandInput} for command's `input` shape.
- * @see {@link UpdateConfigurationSetTrackingOptionsCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateConfigurationSetTrackingOptionsCommand extends $Command<UpdateConfigurationSetTrackingOptionsCommandInput, UpdateConfigurationSetTrackingOptionsCommandOutput, SESClientResolvedConfig> {
     readonly input: UpdateConfigurationSetTrackingOptionsCommandInput;
     constructor(input: UpdateConfigurationSetTrackingOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConfigurationSetTrackingOptionsCommandInput, UpdateConfigurationSetTrackingOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface UpdateCustomVerificationEmailTemplateCommandInput extends Updat
 }
 export interface UpdateCustomVerificationEmailTemplateCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Updates an existing custom verification email template.</p>
- *         <p>For more information about 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, UpdateCustomVerificationEmailTemplateCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, UpdateCustomVerificationEmailTemplateCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new UpdateCustomVerificationEmailTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateCustomVerificationEmailTemplateCommandInput} for command's `input` shape.
- * @see {@link UpdateCustomVerificationEmailTemplateCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateCustomVerificationEmailTemplateCommand extends $Command<UpdateCustomVerificationEmailTemplateCommandInput, UpdateCustomVerificationEmailTemplateCommandOutput, SESClientResolvedConfig> {
     readonly input: UpdateCustomVerificationEmailTemplateCommandInput;
     constructor(input: UpdateCustomVerificationEmailTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCustomVerificationEmailTemplateCommandInput, UpdateCustomVerificationEmailTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface UpdateReceiptRuleCommandInput extends UpdateReceiptRuleRequest
 }
 export interface UpdateReceiptRuleCommandOutput extends UpdateReceiptRuleResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a receipt rule.</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, UpdateReceiptRuleCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, UpdateReceiptRuleCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new UpdateReceiptRuleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateReceiptRuleCommandInput} for command's `input` shape.
- * @see {@link UpdateReceiptRuleCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateReceiptRuleCommand extends $Command<UpdateReceiptRuleCommandInput, UpdateReceiptRuleCommandOutput, SESClientResolvedConfig> {
     readonly input: UpdateReceiptRuleCommandInput;
     constructor(input: UpdateReceiptRuleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateReceiptRuleCommandInput, UpdateReceiptRuleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface UpdateTemplateCommandInput extends UpdateTemplateRequest {
 }
 export interface UpdateTemplateCommandOutput extends UpdateTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Updates an email template. Email templates enable you to send personalized email to
- *             one or more destinations in a single API operation. For more information, see the <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.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, UpdateTemplateCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, UpdateTemplateCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new UpdateTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateTemplateCommandInput} for command's `input` shape.
- * @see {@link UpdateTemplateCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateTemplateCommand extends $Command<UpdateTemplateCommandInput, UpdateTemplateCommandOutput, SESClientResolvedConfig> {
     readonly input: UpdateTemplateCommandInput;
     constructor(input: UpdateTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateTemplateCommandInput, UpdateTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,67 +6,11 @@ export interface VerifyDomainDkimCommandInput extends VerifyDomainDkimRequest {
 }
 export interface VerifyDomainDkimCommandOutput extends VerifyDomainDkimResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a set of DKIM tokens for a domain identity.</p>
- *         <important>
- *             <p>When you execute the <code>VerifyDomainDkim</code> operation, the domain that you
- *                 specify is added to the list of identities that are associated with your account.
- *                 This is true even if you haven't already associated the domain with your account by
- *                 using the <code>VerifyDomainIdentity</code> operation. However, you can't send email
- *                 from the domain until you either successfully <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-domains.html">verify it</a> or you
- *                 successfully <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">set up DKIM for
- *                 it</a>.</p>
- *         </important>
- *         <p>You use the tokens that are generated by this operation to create CNAME records. When
- *             Amazon SES detects that you've added these records to the DNS configuration for a domain, you
- *             can start sending email from that domain. You can start sending email even if you
- *             haven't added the TXT record provided by the VerifyDomainIdentity operation to the DNS
- *             configuration for your domain. All email that you send from the domain is authenticated
- *             using DKIM.</p>
- *         <p>To create the CNAME records for DKIM authentication, use the following values:</p>
- *         <ul>
- *             <li>
- *                 <p>
- *                   <b>Name</b>:
- *                         <i>token</i>._domainkey.<i>example.com</i>
- *                </p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <b>Type</b>: CNAME</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <b>Value</b>:
- *                     <i>token</i>.dkim.amazonses.com</p>
- *             </li>
- *          </ul>
- *         <p>In the preceding example, replace <i>token</i> with one of the tokens
- *             that are generated when you execute this operation. Replace
- *                 <i>example.com</i> with your domain. Repeat this process for each
- *             token that's generated by this operation.</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, VerifyDomainDkimCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, VerifyDomainDkimCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new VerifyDomainDkimCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link VerifyDomainDkimCommandInput} for command's `input` shape.
- * @see {@link VerifyDomainDkimCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class VerifyDomainDkimCommand extends $Command<VerifyDomainDkimCommandInput, VerifyDomainDkimCommandOutput, SESClientResolvedConfig> {
     readonly input: VerifyDomainDkimCommandInput;
     constructor(input: VerifyDomainDkimCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<VerifyDomainDkimCommandInput, VerifyDomainDkimCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface VerifyDomainIdentityCommandInput extends VerifyDomainIdentityRe
 }
 export interface VerifyDomainIdentityCommandOutput extends VerifyDomainIdentityResponse, __MetadataBearer {
 }
-/**
- * <p>Adds a domain to the list of identities for your Amazon SES account in the current AWS
- *             Region and attempts to verify it. For more information about verifying domains, 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>
- *         <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, VerifyDomainIdentityCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, VerifyDomainIdentityCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new VerifyDomainIdentityCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link VerifyDomainIdentityCommandInput} for command's `input` shape.
- * @see {@link VerifyDomainIdentityCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class VerifyDomainIdentityCommand extends $Command<VerifyDomainIdentityCommandInput, VerifyDomainIdentityCommandOutput, SESClientResolvedConfig> {
     readonly input: VerifyDomainIdentityCommandInput;
     constructor(input: VerifyDomainIdentityCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<VerifyDomainIdentityCommandInput, VerifyDomainIdentityCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface VerifyEmailAddressCommandInput extends VerifyEmailAddressReques
 }
 export interface VerifyEmailAddressCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deprecated. Use the <code>VerifyEmailIdentity</code> operation to verify a new email
- *             address.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESClient, VerifyEmailAddressCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, VerifyEmailAddressCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new VerifyEmailAddressCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link VerifyEmailAddressCommandInput} for command's `input` shape.
- * @see {@link VerifyEmailAddressCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class VerifyEmailAddressCommand extends $Command<VerifyEmailAddressCommandInput, VerifyEmailAddressCommandOutput, SESClientResolvedConfig> {
     readonly input: VerifyEmailAddressCommandInput;
     constructor(input: VerifyEmailAddressCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<VerifyEmailAddressCommandInput, VerifyEmailAddressCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface VerifyEmailIdentityCommandInput extends VerifyEmailIdentityRequ
 }
 export interface VerifyEmailIdentityCommandOutput extends VerifyEmailIdentityResponse, __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
- *             verification email is sent to the specified address.</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, VerifyEmailIdentityCommand } from "@aws-sdk/client-ses"; // ES Modules import
- * // const { SESClient, VerifyEmailIdentityCommand } = require("@aws-sdk/client-ses"); // CommonJS import
- * const client = new SESClient(config);
- * const command = new VerifyEmailIdentityCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link VerifyEmailIdentityCommandInput} for command's `input` shape.
- * @see {@link VerifyEmailIdentityCommandOutput} for command's `response` shape.
- * @see {@link SESClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class VerifyEmailIdentityCommand extends $Command<VerifyEmailIdentityCommandInput, VerifyEmailIdentityCommandOutput, SESClientResolvedConfig> {
     readonly input: VerifyEmailIdentityCommandInput;
     constructor(input: VerifyEmailIdentityCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESClientResolvedConfig, options?: __HttpHandlerOptions): Handler<VerifyEmailIdentityCommandInput, VerifyEmailIdentityCommandOutput>;
     private serialize;
     private deserialize;