@aws-sdk/client-sesv2 3.35.0 → 3.38.0

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

@@ -6,38 +6,11 @@ export interface PutEmailIdentityFeedbackAttributesCommandInput extends PutEmail
 }
 export interface PutEmailIdentityFeedbackAttributesCommandOutput extends PutEmailIdentityFeedbackAttributesResponse, __MetadataBearer {
 }
-/**
- * <p>Used to enable or disable feedback forwarding for an identity. This setting determines
- *             what happens when an identity is used to send an email that results in a bounce or
- *             complaint event.</p>
- *         <p>If the value is <code>true</code>, you receive email notifications when bounce or
- *             complaint events occur. These notifications are sent to the address that you specified
- *             in the <code>Return-Path</code> header of the original email.</p>
- *         <p>You're required to have a method of tracking bounces and complaints. If you haven't
- *             set up another mechanism for receiving bounce or complaint notifications (for example,
- *             by setting up an event destination), you receive an email notification when these events
- *             occur (even if this setting is disabled).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, PutEmailIdentityFeedbackAttributesCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, PutEmailIdentityFeedbackAttributesCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new PutEmailIdentityFeedbackAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutEmailIdentityFeedbackAttributesCommandInput} for command's `input` shape.
- * @see {@link PutEmailIdentityFeedbackAttributesCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutEmailIdentityFeedbackAttributesCommand extends $Command<PutEmailIdentityFeedbackAttributesCommandInput, PutEmailIdentityFeedbackAttributesCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: PutEmailIdentityFeedbackAttributesCommandInput;
     constructor(input: PutEmailIdentityFeedbackAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEmailIdentityFeedbackAttributesCommandInput, PutEmailIdentityFeedbackAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface PutEmailIdentityMailFromAttributesCommandInput extends PutEmail
 }
 export interface PutEmailIdentityMailFromAttributesCommandOutput extends PutEmailIdentityMailFromAttributesResponse, __MetadataBearer {
 }
-/**
- * <p>Used to enable or disable the custom Mail-From domain configuration for an email
- *             identity.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, PutEmailIdentityMailFromAttributesCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, PutEmailIdentityMailFromAttributesCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new PutEmailIdentityMailFromAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutEmailIdentityMailFromAttributesCommandInput} for command's `input` shape.
- * @see {@link PutEmailIdentityMailFromAttributesCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutEmailIdentityMailFromAttributesCommand extends $Command<PutEmailIdentityMailFromAttributesCommandInput, PutEmailIdentityMailFromAttributesCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: PutEmailIdentityMailFromAttributesCommandInput;
     constructor(input: PutEmailIdentityMailFromAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEmailIdentityMailFromAttributesCommandInput, PutEmailIdentityMailFromAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutSuppressedDestinationCommandInput extends PutSuppressedDesti
 }
 export interface PutSuppressedDestinationCommandOutput extends PutSuppressedDestinationResponse, __MetadataBearer {
 }
-/**
- * <p>Adds an email address to the suppression list for your account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, PutSuppressedDestinationCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, PutSuppressedDestinationCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new PutSuppressedDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutSuppressedDestinationCommandInput} for command's `input` shape.
- * @see {@link PutSuppressedDestinationCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutSuppressedDestinationCommand extends $Command<PutSuppressedDestinationCommandInput, PutSuppressedDestinationCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: PutSuppressedDestinationCommandInput;
     constructor(input: PutSuppressedDestinationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutSuppressedDestinationCommandInput, PutSuppressedDestinationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface SendBulkEmailCommandInput extends SendBulkEmailRequest {
 }
 export interface SendBulkEmailCommandOutput extends SendBulkEmailResponse, __MetadataBearer {
 }
-/**
- * <p>Composes an email message to multiple destinations.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, SendBulkEmailCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, SendBulkEmailCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new SendBulkEmailCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendBulkEmailCommandInput} for command's `input` shape.
- * @see {@link SendBulkEmailCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SendBulkEmailCommand extends $Command<SendBulkEmailCommandInput, SendBulkEmailCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: SendBulkEmailCommandInput;
     constructor(input: SendBulkEmailCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendBulkEmailCommandInput, SendBulkEmailCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface SendCustomVerificationEmailCommandInput extends SendCustomVerif
 }
 export interface SendCustomVerificationEmailCommandOutput extends SendCustomVerificationEmailResponse, __MetadataBearer {
 }
-/**
- * <p>Adds an email address to the list of identities for your Amazon SES account in the current
- *             Amazon Web Services 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/send-email-verify-address-custom.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 { SESv2Client, SendCustomVerificationEmailCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, SendCustomVerificationEmailCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(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 SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SendCustomVerificationEmailCommand extends $Command<SendCustomVerificationEmailCommandInput, SendCustomVerificationEmailCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: SendCustomVerificationEmailCommandInput;
     constructor(input: SendCustomVerificationEmailCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendCustomVerificationEmailCommandInput, SendCustomVerificationEmailCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,52 +6,11 @@ export interface SendEmailCommandInput extends SendEmailRequest {
 }
 export interface SendEmailCommandOutput extends SendEmailResponse, __MetadataBearer {
 }
-/**
- * <p>Sends an email message. You can use the Amazon SES API v2 to send the following types of
- *             messages:</p>
- *         <ul>
- *             <li>
- *                 <p>
- *                   <b>Simple</b> – A standard email message. When
- *                     you create this type of message, you specify the sender, the recipient, and the
- *                     message body, and Amazon SES assembles the message for you.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <b>Raw</b> – A raw, MIME-formatted email
- *                     message. When you send this type of email, you have to specify all of the
- *                     message headers, as well as the message body. You can use this message type to
- *                     send messages that contain attachments. The message that you specify has to be a
- *                     valid MIME message.</p>
- *             </li>
- *             <li>
- *                 <p>
- *                   <b>Templated</b> – A message that contains
- *                     personalization tags. When you send this type of email, Amazon SES API v2 automatically
- *                     replaces the tags with values that you specify.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, SendEmailCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, SendEmailCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(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 SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SendEmailCommand extends $Command<SendEmailCommandInput, SendEmailCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: SendEmailCommandInput;
     constructor(input: SendEmailCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendEmailCommandInput, SendEmailCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Add one or more tags (keys and values) to a specified resource. A
- *                 <i>tag</i> is a label that you optionally define and associate with a
- *             resource. Tags can help you categorize and manage resources in different ways, such as
- *             by purpose, owner, environment, or other criteria. A resource can have as many as 50
- *             tags.</p>
- *         <p>Each tag consists of a required <i>tag key</i> and an
- *                 associated <i>tag value</i>, both of which you define. A tag key is a
- *             general label that acts as a category for more specific tag values. A tag value acts as
- *             a descriptor within a tag key.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, TagResourceCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, TagResourceCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface TestRenderEmailTemplateCommandInput extends TestRenderEmailTemp
 }
 export interface TestRenderEmailTemplateCommandOutput extends TestRenderEmailTemplateResponse, __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 { SESv2Client, TestRenderEmailTemplateCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, TestRenderEmailTemplateCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new TestRenderEmailTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TestRenderEmailTemplateCommandInput} for command's `input` shape.
- * @see {@link TestRenderEmailTemplateCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TestRenderEmailTemplateCommand extends $Command<TestRenderEmailTemplateCommandInput, TestRenderEmailTemplateCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: TestRenderEmailTemplateCommandInput;
     constructor(input: TestRenderEmailTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestRenderEmailTemplateCommandInput, TestRenderEmailTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Remove one or more tags (keys and values) from a specified resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, UntagResourceCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, UntagResourceCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface UpdateConfigurationSetEventDestinationCommandInput extends Upda
 }
 export interface UpdateConfigurationSetEventDestinationCommandOutput extends UpdateConfigurationSetEventDestinationResponse, __MetadataBearer {
 }
-/**
- * <p>Update the configuration of an event destination for a configuration set.</p>
- *         <p>
- *             <i>Events</i> include message sends, deliveries, opens, clicks, bounces,
- *             and complaints. <i>Event destinations</i> are places that you can send
- *             information about these events to. For example, you can send event data to Amazon SNS to
- *             receive notifications when you receive bounces or complaints, or you can use Amazon Kinesis Data Firehose to
- *             stream data to Amazon S3 for long-term storage.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, UpdateConfigurationSetEventDestinationCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, UpdateConfigurationSetEventDestinationCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(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 SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateConfigurationSetEventDestinationCommand extends $Command<UpdateConfigurationSetEventDestinationCommandInput, UpdateConfigurationSetEventDestinationCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: UpdateConfigurationSetEventDestinationCommandInput;
     constructor(input: UpdateConfigurationSetEventDestinationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConfigurationSetEventDestinationCommandInput, UpdateConfigurationSetEventDestinationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface UpdateContactCommandInput extends UpdateContactRequest {
 }
 export interface UpdateContactCommandOutput extends UpdateContactResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a contact's preferences for a list. It is not necessary to specify all
- *             existing topic preferences in the TopicPreferences object, just the ones that need
- *             updating.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, UpdateContactCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, UpdateContactCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new UpdateContactCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateContactCommandInput} for command's `input` shape.
- * @see {@link UpdateContactCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateContactCommand extends $Command<UpdateContactCommandInput, UpdateContactCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: UpdateContactCommandInput;
     constructor(input: UpdateContactCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateContactCommandInput, UpdateContactCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateContactListCommandInput extends UpdateContactListRequest
 }
 export interface UpdateContactListCommandOutput extends UpdateContactListResponse, __MetadataBearer {
 }
-/**
- * <p>Updates contact list metadata. This operation does a complete replacement.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, UpdateContactListCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, UpdateContactListCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new UpdateContactListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateContactListCommandInput} for command's `input` shape.
- * @see {@link UpdateContactListCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateContactListCommand extends $Command<UpdateContactListCommandInput, UpdateContactListCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: UpdateContactListCommandInput;
     constructor(input: UpdateContactListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateContactListCommandInput, UpdateContactListCommandOutput>;
     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 UpdateCustomVerificationEmailTemplateResponse, __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/send-email-verify-address-custom.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 { SESv2Client, UpdateCustomVerificationEmailTemplateCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, UpdateCustomVerificationEmailTemplateCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(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 SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateCustomVerificationEmailTemplateCommand extends $Command<UpdateCustomVerificationEmailTemplateCommandInput, UpdateCustomVerificationEmailTemplateCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: UpdateCustomVerificationEmailTemplateCommandInput;
     constructor(input: UpdateCustomVerificationEmailTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCustomVerificationEmailTemplateCommandInput, UpdateCustomVerificationEmailTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface UpdateEmailIdentityPolicyCommandInput extends UpdateEmailIdenti
 }
 export interface UpdateEmailIdentityPolicyCommandOutput extends UpdateEmailIdentityPolicyResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the specified sending authorization policy for the given identity (an email
- *             address or a domain). This API returns successfully even if a policy with the specified
- *             name does not exist.</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 { SESv2Client, UpdateEmailIdentityPolicyCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, UpdateEmailIdentityPolicyCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new UpdateEmailIdentityPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateEmailIdentityPolicyCommandInput} for command's `input` shape.
- * @see {@link UpdateEmailIdentityPolicyCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateEmailIdentityPolicyCommand extends $Command<UpdateEmailIdentityPolicyCommandInput, UpdateEmailIdentityPolicyCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: UpdateEmailIdentityPolicyCommandInput;
     constructor(input: UpdateEmailIdentityPolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEmailIdentityPolicyCommandInput, UpdateEmailIdentityPolicyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface UpdateEmailTemplateCommandInput extends UpdateEmailTemplateRequ
 }
 export interface UpdateEmailTemplateCommandOutput extends UpdateEmailTemplateResponse, __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 { SESv2Client, UpdateEmailTemplateCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, UpdateEmailTemplateCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new UpdateEmailTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateEmailTemplateCommandInput} for command's `input` shape.
- * @see {@link UpdateEmailTemplateCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateEmailTemplateCommand extends $Command<UpdateEmailTemplateCommandInput, UpdateEmailTemplateCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: UpdateEmailTemplateCommandInput;
     constructor(input: UpdateEmailTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEmailTemplateCommandInput, UpdateEmailTemplateCommandOutput>;
     private serialize;
     private deserialize;