@aws-sdk/client-sesv2 3.35.0 → 3.38.0

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

@@ -6,35 +6,11 @@ export interface DeleteConfigurationSetEventDestinationCommandInput extends Dele
 }
 export interface DeleteConfigurationSetEventDestinationCommandOutput extends DeleteConfigurationSetEventDestinationResponse, __MetadataBearer {
 }
-/**
- * <p>Delete an event destination.</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, DeleteConfigurationSetEventDestinationCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, DeleteConfigurationSetEventDestinationCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new DeleteConfigurationSetEventDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteConfigurationSetEventDestinationCommandInput} for command's `input` shape.
- * @see {@link DeleteConfigurationSetEventDestinationCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteConfigurationSetEventDestinationCommand extends $Command<DeleteConfigurationSetEventDestinationCommandInput, DeleteConfigurationSetEventDestinationCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: DeleteConfigurationSetEventDestinationCommandInput;
     constructor(input: DeleteConfigurationSetEventDestinationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConfigurationSetEventDestinationCommandInput, DeleteConfigurationSetEventDestinationCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface DeleteContactListCommandInput extends DeleteContactListRequest
 }
 export interface DeleteContactListCommandOutput extends DeleteContactListResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a contact list and all of the contacts on that list.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, DeleteContactListCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, DeleteContactListCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new DeleteContactListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteContactListCommandInput} for command's `input` shape.
- * @see {@link DeleteContactListCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteContactListCommand extends $Command<DeleteContactListCommandInput, DeleteContactListCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: DeleteContactListCommandInput;
     constructor(input: DeleteContactListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteContactListCommandInput, DeleteContactListCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,31 +6,11 @@ export interface DeleteEmailTemplateCommandInput extends DeleteEmailTemplateRequ
 }
 export interface DeleteEmailTemplateCommandOutput extends DeleteEmailTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an email template.</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, DeleteEmailTemplateCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, DeleteEmailTemplateCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new DeleteEmailTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEmailTemplateCommandInput} for command's `input` shape.
- * @see {@link DeleteEmailTemplateCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteEmailTemplateCommand extends $Command<DeleteEmailTemplateCommandInput, DeleteEmailTemplateCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: DeleteEmailTemplateCommandInput;
     constructor(input: DeleteEmailTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEmailTemplateCommandInput, DeleteEmailTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteSuppressedDestinationCommandInput extends DeleteSuppresse
 }
 export interface DeleteSuppressedDestinationCommandOutput extends DeleteSuppressedDestinationResponse, __MetadataBearer {
 }
-/**
- * <p>Removes an email address from 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, DeleteSuppressedDestinationCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, DeleteSuppressedDestinationCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new DeleteSuppressedDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteSuppressedDestinationCommandInput} for command's `input` shape.
- * @see {@link DeleteSuppressedDestinationCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteSuppressedDestinationCommand extends $Command<DeleteSuppressedDestinationCommandInput, DeleteSuppressedDestinationCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: DeleteSuppressedDestinationCommandInput;
     constructor(input: DeleteSuppressedDestinationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSuppressedDestinationCommandInput, DeleteSuppressedDestinationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetAccountCommandInput extends GetAccountRequest {
 }
 export interface GetAccountCommandOutput extends GetAccountResponse, __MetadataBearer {
 }
-/**
- * <p>Obtain information about the email-sending status and capabilities of your Amazon SES
- *             account in the current Amazon Web Services Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, GetAccountCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetAccountCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetAccountCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetAccountCommandInput} for command's `input` shape.
- * @see {@link GetAccountCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetAccountCommand extends $Command<GetAccountCommandInput, GetAccountCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetAccountCommandInput;
     constructor(input: GetAccountCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetAccountCommandInput, GetAccountCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetBlacklistReportsCommandInput extends GetBlacklistReportsRequ
 }
 export interface GetBlacklistReportsCommandOutput extends GetBlacklistReportsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieve a list of the blacklists that your dedicated IP addresses appear on.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, GetBlacklistReportsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetBlacklistReportsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetBlacklistReportsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBlacklistReportsCommandInput} for command's `input` shape.
- * @see {@link GetBlacklistReportsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetBlacklistReportsCommand extends $Command<GetBlacklistReportsCommandInput, GetBlacklistReportsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetBlacklistReportsCommandInput;
     constructor(input: GetBlacklistReportsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBlacklistReportsCommandInput, GetBlacklistReportsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface GetConfigurationSetCommandInput extends GetConfigurationSetRequ
 }
 export interface GetConfigurationSetCommandOutput extends GetConfigurationSetResponse, __MetadataBearer {
 }
-/**
- * <p>Get information about an existing configuration set, including the dedicated IP pool
- *             that it's associated with, whether or not it's enabled for sending email, and
- *             more.</p>
- *         <p>
- *             <i>Configuration sets</i> are groups of rules that you can apply to the
- *             emails you send. You apply a configuration set to an email by including a reference to
- *             the configuration set in the headers of the email. When you apply a configuration set to
- *             an email, all of the rules in that configuration set are applied to the email.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, GetConfigurationSetCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetConfigurationSetCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetConfigurationSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetConfigurationSetCommandInput} for command's `input` shape.
- * @see {@link GetConfigurationSetCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetConfigurationSetCommand extends $Command<GetConfigurationSetCommandInput, GetConfigurationSetCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetConfigurationSetCommandInput;
     constructor(input: GetConfigurationSetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConfigurationSetCommandInput, GetConfigurationSetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface GetConfigurationSetEventDestinationsCommandInput extends GetCon
 }
 export interface GetConfigurationSetEventDestinationsCommandOutput extends GetConfigurationSetEventDestinationsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieve a list of event destinations that are associated with 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, GetConfigurationSetEventDestinationsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetConfigurationSetEventDestinationsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetConfigurationSetEventDestinationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetConfigurationSetEventDestinationsCommandInput} for command's `input` shape.
- * @see {@link GetConfigurationSetEventDestinationsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetConfigurationSetEventDestinationsCommand extends $Command<GetConfigurationSetEventDestinationsCommandInput, GetConfigurationSetEventDestinationsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetConfigurationSetEventDestinationsCommandInput;
     constructor(input: GetConfigurationSetEventDestinationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConfigurationSetEventDestinationsCommandInput, GetConfigurationSetEventDestinationsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface GetContactListCommandInput extends GetContactListRequest {
 }
 export interface GetContactListCommandOutput extends GetContactListResponse, __MetadataBearer {
 }
-/**
- * <p>Returns contact list metadata. It does not return any information about the contacts
- *             present in the list.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, GetContactListCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetContactListCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetContactListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetContactListCommandInput} for command's `input` shape.
- * @see {@link GetContactListCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetContactListCommand extends $Command<GetContactListCommandInput, GetContactListCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetContactListCommandInput;
     constructor(input: GetContactListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetContactListCommandInput, GetContactListCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface GetCustomVerificationEmailTemplateCommandInput extends GetCusto
 }
 export interface GetCustomVerificationEmailTemplateCommandOutput extends GetCustomVerificationEmailTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the custom email verification template for the template name you
- *             specify.</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, GetCustomVerificationEmailTemplateCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetCustomVerificationEmailTemplateCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetCustomVerificationEmailTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCustomVerificationEmailTemplateCommandInput} for command's `input` shape.
- * @see {@link GetCustomVerificationEmailTemplateCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetCustomVerificationEmailTemplateCommand extends $Command<GetCustomVerificationEmailTemplateCommandInput, GetCustomVerificationEmailTemplateCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetCustomVerificationEmailTemplateCommandInput;
     constructor(input: GetCustomVerificationEmailTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCustomVerificationEmailTemplateCommandInput, GetCustomVerificationEmailTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface GetDedicatedIpCommandInput extends GetDedicatedIpRequest {
 }
 export interface GetDedicatedIpCommandOutput extends GetDedicatedIpResponse, __MetadataBearer {
 }
-/**
- * <p>Get information about a dedicated IP address, including the name of the dedicated IP
- *             pool that it's associated with, as well information about the automatic warm-up process
- *             for the address.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, GetDedicatedIpCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetDedicatedIpCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetDedicatedIpCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDedicatedIpCommandInput} for command's `input` shape.
- * @see {@link GetDedicatedIpCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDedicatedIpCommand extends $Command<GetDedicatedIpCommandInput, GetDedicatedIpCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetDedicatedIpCommandInput;
     constructor(input: GetDedicatedIpCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDedicatedIpCommandInput, GetDedicatedIpCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface GetDedicatedIpsCommandInput extends GetDedicatedIpsRequest {
 }
 export interface GetDedicatedIpsCommandOutput extends GetDedicatedIpsResponse, __MetadataBearer {
 }
-/**
- * <p>List the dedicated IP addresses that are associated with your Amazon Web Services
- *             account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, GetDedicatedIpsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetDedicatedIpsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetDedicatedIpsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDedicatedIpsCommandInput} for command's `input` shape.
- * @see {@link GetDedicatedIpsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDedicatedIpsCommand extends $Command<GetDedicatedIpsCommandInput, GetDedicatedIpsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetDedicatedIpsCommandInput;
     constructor(input: GetDedicatedIpsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDedicatedIpsCommandInput, GetDedicatedIpsCommandOutput>;
     private serialize;
     private deserialize;