@aws-sdk/client-sesv2 3.35.0 → 3.38.0

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

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

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

@@ -6,30 +6,11 @@ export interface ListSuppressedDestinationsCommandInput extends ListSuppressedDe
 }
 export interface ListSuppressedDestinationsCommandOutput extends ListSuppressedDestinationsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves a list of email addresses that are on 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, ListSuppressedDestinationsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, ListSuppressedDestinationsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new ListSuppressedDestinationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSuppressedDestinationsCommandInput} for command's `input` shape.
- * @see {@link ListSuppressedDestinationsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListSuppressedDestinationsCommand extends $Command<ListSuppressedDestinationsCommandInput, ListSuppressedDestinationsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: ListSuppressedDestinationsCommandInput;
     constructor(input: ListSuppressedDestinationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSuppressedDestinationsCommandInput, ListSuppressedDestinationsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieve a list of the tags (keys and values) that are associated with a specified
- *             resource. A <i>tag</i> is a label that you optionally define and associate
- *             with a resource. Each tag consists of a required <i>tag key</i> and an
- *             optional associated <i>tag value</i>. 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, ListTagsForResourceCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, ListTagsForResourceCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface PutConfigurationSetDeliveryOptionsCommandInput extends PutConfi
 }
 export interface PutConfigurationSetDeliveryOptionsCommandOutput extends PutConfigurationSetDeliveryOptionsResponse, __MetadataBearer {
 }
-/**
- * <p>Associate a configuration set with a dedicated IP pool. You can use dedicated IP pools
- *             to create groups of dedicated IP addresses for sending specific types of email.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, PutConfigurationSetDeliveryOptionsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, PutConfigurationSetDeliveryOptionsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new PutConfigurationSetDeliveryOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutConfigurationSetDeliveryOptionsCommandInput} for command's `input` shape.
- * @see {@link PutConfigurationSetDeliveryOptionsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutConfigurationSetDeliveryOptionsCommand extends $Command<PutConfigurationSetDeliveryOptionsCommandInput, PutConfigurationSetDeliveryOptionsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: PutConfigurationSetDeliveryOptionsCommandInput;
     constructor(input: PutConfigurationSetDeliveryOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutConfigurationSetDeliveryOptionsCommandInput, PutConfigurationSetDeliveryOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface PutConfigurationSetReputationOptionsCommandInput extends PutCon
 }
 export interface PutConfigurationSetReputationOptionsCommandOutput extends PutConfigurationSetReputationOptionsResponse, __MetadataBearer {
 }
-/**
- * <p>Enable or disable collection of reputation metrics for emails that you send using a
- *             particular configuration set in a specific Amazon Web Services Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, PutConfigurationSetReputationOptionsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, PutConfigurationSetReputationOptionsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new PutConfigurationSetReputationOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutConfigurationSetReputationOptionsCommandInput} for command's `input` shape.
- * @see {@link PutConfigurationSetReputationOptionsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutConfigurationSetReputationOptionsCommand extends $Command<PutConfigurationSetReputationOptionsCommandInput, PutConfigurationSetReputationOptionsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: PutConfigurationSetReputationOptionsCommandInput;
     constructor(input: PutConfigurationSetReputationOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutConfigurationSetReputationOptionsCommandInput, PutConfigurationSetReputationOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface PutConfigurationSetSendingOptionsCommandInput extends PutConfig
 }
 export interface PutConfigurationSetSendingOptionsCommandOutput extends PutConfigurationSetSendingOptionsResponse, __MetadataBearer {
 }
-/**
- * <p>Enable or disable email sending for messages that use a particular configuration set
- *             in a specific Amazon Web Services Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, PutConfigurationSetSendingOptionsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, PutConfigurationSetSendingOptionsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new PutConfigurationSetSendingOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutConfigurationSetSendingOptionsCommandInput} for command's `input` shape.
- * @see {@link PutConfigurationSetSendingOptionsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutConfigurationSetSendingOptionsCommand extends $Command<PutConfigurationSetSendingOptionsCommandInput, PutConfigurationSetSendingOptionsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: PutConfigurationSetSendingOptionsCommandInput;
     constructor(input: PutConfigurationSetSendingOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutConfigurationSetSendingOptionsCommandInput, PutConfigurationSetSendingOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface PutConfigurationSetTrackingOptionsCommandInput extends PutConfi
 }
 export interface PutConfigurationSetTrackingOptionsCommandOutput extends PutConfigurationSetTrackingOptionsResponse, __MetadataBearer {
 }
-/**
- * <p>Specify a custom domain to use for open and click tracking elements in email that you
- *             send.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, PutConfigurationSetTrackingOptionsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, PutConfigurationSetTrackingOptionsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new PutConfigurationSetTrackingOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutConfigurationSetTrackingOptionsCommandInput} for command's `input` shape.
- * @see {@link PutConfigurationSetTrackingOptionsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutConfigurationSetTrackingOptionsCommand extends $Command<PutConfigurationSetTrackingOptionsCommandInput, PutConfigurationSetTrackingOptionsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: PutConfigurationSetTrackingOptionsCommandInput;
     constructor(input: PutConfigurationSetTrackingOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutConfigurationSetTrackingOptionsCommandInput, PutConfigurationSetTrackingOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface PutDedicatedIpInPoolCommandInput extends PutDedicatedIpInPoolRe
 }
 export interface PutDedicatedIpInPoolCommandOutput extends PutDedicatedIpInPoolResponse, __MetadataBearer {
 }
-/**
- * <p>Move a dedicated IP address to an existing dedicated IP pool.</p>
- *         <note>
- *             <p>The dedicated IP address that you specify must already exist, and must be
- *                 associated with your Amazon Web Services account.
- *
- *             </p>
- *             <p>The dedicated IP pool you specify must already exist. You can create a new pool by
- *                 using the <code>CreateDedicatedIpPool</code> operation.</p>
- *
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, PutDedicatedIpInPoolCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, PutDedicatedIpInPoolCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new PutDedicatedIpInPoolCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutDedicatedIpInPoolCommandInput} for command's `input` shape.
- * @see {@link PutDedicatedIpInPoolCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutDedicatedIpInPoolCommand extends $Command<PutDedicatedIpInPoolCommandInput, PutDedicatedIpInPoolCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: PutDedicatedIpInPoolCommandInput;
     constructor(input: PutDedicatedIpInPoolCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutDedicatedIpInPoolCommandInput, PutDedicatedIpInPoolCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,35 +6,11 @@ export interface PutDeliverabilityDashboardOptionCommandInput extends PutDeliver
 }
 export interface PutDeliverabilityDashboardOptionCommandOutput extends PutDeliverabilityDashboardOptionResponse, __MetadataBearer {
 }
-/**
- * <p>Enable or disable the Deliverability dashboard. When you enable the Deliverability dashboard, you gain
- *             access to reputation, deliverability, and other metrics for the domains that you use to
- *             send email. You also gain the ability to perform predictive inbox placement tests.</p>
- *
- *         <p>When you use the Deliverability dashboard, you pay a monthly subscription charge, in addition
- *             to any other fees that you accrue by using Amazon SES and other Amazon Web Services services. For more
- *             information about the features and cost of a Deliverability dashboard subscription, see <a href="http://aws.amazon.com/ses/pricing/">Amazon SES Pricing</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, PutDeliverabilityDashboardOptionCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, PutDeliverabilityDashboardOptionCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new PutDeliverabilityDashboardOptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutDeliverabilityDashboardOptionCommandInput} for command's `input` shape.
- * @see {@link PutDeliverabilityDashboardOptionCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutDeliverabilityDashboardOptionCommand extends $Command<PutDeliverabilityDashboardOptionCommandInput, PutDeliverabilityDashboardOptionCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: PutDeliverabilityDashboardOptionCommandInput;
     constructor(input: PutDeliverabilityDashboardOptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutDeliverabilityDashboardOptionCommandInput, PutDeliverabilityDashboardOptionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,51 +6,11 @@ export interface PutEmailIdentityDkimSigningAttributesCommandInput extends PutEm
 }
 export interface PutEmailIdentityDkimSigningAttributesCommandOutput extends PutEmailIdentityDkimSigningAttributesResponse, __MetadataBearer {
 }
-/**
- * <p>Used to configure or change the DKIM authentication settings for an email domain
- *             identity. You can use this operation to do any of the following:</p>
- *         <ul>
- *             <li>
- *                 <p>Update the signing attributes for an identity that uses Bring Your Own DKIM
- *                     (BYODKIM).</p>
- *             </li>
- *             <li>
- *                 <p>Update the key length that should be used for Easy DKIM.</p>
- *             </li>
- *             <li>
- *                 <p>Change from using no DKIM authentication to using Easy DKIM.</p>
- *             </li>
- *             <li>
- *                 <p>Change from using no DKIM authentication to using BYODKIM.</p>
- *             </li>
- *             <li>
- *                 <p>Change from using Easy DKIM to using BYODKIM.</p>
- *             </li>
- *             <li>
- *                 <p>Change from using BYODKIM to using Easy DKIM.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, PutEmailIdentityDkimSigningAttributesCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, PutEmailIdentityDkimSigningAttributesCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new PutEmailIdentityDkimSigningAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutEmailIdentityDkimSigningAttributesCommandInput} for command's `input` shape.
- * @see {@link PutEmailIdentityDkimSigningAttributesCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutEmailIdentityDkimSigningAttributesCommand extends $Command<PutEmailIdentityDkimSigningAttributesCommandInput, PutEmailIdentityDkimSigningAttributesCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: PutEmailIdentityDkimSigningAttributesCommandInput;
     constructor(input: PutEmailIdentityDkimSigningAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEmailIdentityDkimSigningAttributesCommandInput, PutEmailIdentityDkimSigningAttributesCommandOutput>;
     private serialize;
     private deserialize;