@aws-sdk/client-sesv2 3.35.0 → 3.38.0

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

@@ -6,36 +6,11 @@ export interface GetDeliverabilityDashboardOptionsCommandInput extends GetDelive
 }
 export interface GetDeliverabilityDashboardOptionsCommandOutput extends GetDeliverabilityDashboardOptionsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieve information about the status of the Deliverability dashboard for your account. When
- *             the Deliverability dashboard is enabled, 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, GetDeliverabilityDashboardOptionsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetDeliverabilityDashboardOptionsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetDeliverabilityDashboardOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDeliverabilityDashboardOptionsCommandInput} for command's `input` shape.
- * @see {@link GetDeliverabilityDashboardOptionsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDeliverabilityDashboardOptionsCommand extends $Command<GetDeliverabilityDashboardOptionsCommandInput, GetDeliverabilityDashboardOptionsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetDeliverabilityDashboardOptionsCommandInput;
     constructor(input: GetDeliverabilityDashboardOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeliverabilityDashboardOptionsCommandInput, GetDeliverabilityDashboardOptionsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface GetDomainDeliverabilityCampaignCommandInput extends GetDomainDe
 }
 export interface GetDomainDeliverabilityCampaignCommandOutput extends GetDomainDeliverabilityCampaignResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieve all the deliverability data for a specific campaign. This data is available
- *             for a campaign only if the campaign sent email by using a domain that the
- *             Deliverability dashboard is enabled for.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, GetDomainDeliverabilityCampaignCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetDomainDeliverabilityCampaignCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetDomainDeliverabilityCampaignCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDomainDeliverabilityCampaignCommandInput} for command's `input` shape.
- * @see {@link GetDomainDeliverabilityCampaignCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDomainDeliverabilityCampaignCommand extends $Command<GetDomainDeliverabilityCampaignCommandInput, GetDomainDeliverabilityCampaignCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetDomainDeliverabilityCampaignCommandInput;
     constructor(input: GetDomainDeliverabilityCampaignCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDomainDeliverabilityCampaignCommandInput, GetDomainDeliverabilityCampaignCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface GetEmailIdentityCommandInput extends GetEmailIdentityRequest {
 }
 export interface GetEmailIdentityCommandOutput extends GetEmailIdentityResponse, __MetadataBearer {
 }
-/**
- * <p>Provides information about a specific identity, including the identity's verification
- *             status, sending authorization policies, its DKIM authentication status, and its custom
- *             Mail-From settings.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, GetEmailIdentityCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetEmailIdentityCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetEmailIdentityCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEmailIdentityCommandInput} for command's `input` shape.
- * @see {@link GetEmailIdentityCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEmailIdentityCommand extends $Command<GetEmailIdentityCommandInput, GetEmailIdentityCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetEmailIdentityCommandInput;
     constructor(input: GetEmailIdentityCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEmailIdentityCommandInput, GetEmailIdentityCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface GetEmailIdentityPoliciesCommandInput extends GetEmailIdentityPo
 }
 export interface GetEmailIdentityPoliciesCommandOutput extends GetEmailIdentityPoliciesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the requested sending authorization policies for the given identity (an email
- *             address or a domain). The policies are returned as a map of policy names to policy
- *             contents. You can retrieve a maximum of 20 policies at a time.</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, GetEmailIdentityPoliciesCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetEmailIdentityPoliciesCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetEmailIdentityPoliciesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEmailIdentityPoliciesCommandInput} for command's `input` shape.
- * @see {@link GetEmailIdentityPoliciesCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEmailIdentityPoliciesCommand extends $Command<GetEmailIdentityPoliciesCommandInput, GetEmailIdentityPoliciesCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetEmailIdentityPoliciesCommandInput;
     constructor(input: GetEmailIdentityPoliciesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEmailIdentityPoliciesCommandInput, GetEmailIdentityPoliciesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface GetEmailTemplateCommandInput extends GetEmailTemplateRequest {
 }
 export interface GetEmailTemplateCommandOutput extends GetEmailTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Displays the template object (which includes the subject line, HTML part and text
- *             part) for the template you specify.</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, GetEmailTemplateCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, GetEmailTemplateCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new GetEmailTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEmailTemplateCommandInput} for command's `input` shape.
- * @see {@link GetEmailTemplateCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEmailTemplateCommand extends $Command<GetEmailTemplateCommandInput, GetEmailTemplateCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: GetEmailTemplateCommandInput;
     constructor(input: GetEmailTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEmailTemplateCommandInput, GetEmailTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,35 +6,11 @@ export interface ListConfigurationSetsCommandInput extends ListConfigurationSets
 }
 export interface ListConfigurationSetsCommandOutput extends ListConfigurationSetsResponse, __MetadataBearer {
 }
-/**
- * <p>List all of the configuration sets associated with your account in the current
- *             region.</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, ListConfigurationSetsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, ListConfigurationSetsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new ListConfigurationSetsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListConfigurationSetsCommandInput} for command's `input` shape.
- * @see {@link ListConfigurationSetsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListConfigurationSetsCommand extends $Command<ListConfigurationSetsCommandInput, ListConfigurationSetsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: ListConfigurationSetsCommandInput;
     constructor(input: ListConfigurationSetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConfigurationSetsCommandInput, ListConfigurationSetsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,33 +6,11 @@ export interface ListCustomVerificationEmailTemplatesCommandInput extends ListCu
 }
 export interface ListCustomVerificationEmailTemplatesCommandOutput extends ListCustomVerificationEmailTemplatesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the existing custom verification email templates for your account in the current
- *             Amazon Web Services Region.</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, ListCustomVerificationEmailTemplatesCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, ListCustomVerificationEmailTemplatesCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new ListCustomVerificationEmailTemplatesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListCustomVerificationEmailTemplatesCommandInput} for command's `input` shape.
- * @see {@link ListCustomVerificationEmailTemplatesCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListCustomVerificationEmailTemplatesCommand extends $Command<ListCustomVerificationEmailTemplatesCommandInput, ListCustomVerificationEmailTemplatesCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: ListCustomVerificationEmailTemplatesCommandInput;
     constructor(input: ListCustomVerificationEmailTemplatesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCustomVerificationEmailTemplatesCommandInput, ListCustomVerificationEmailTemplatesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface ListDeliverabilityTestReportsCommandInput extends ListDeliverab
 }
 export interface ListDeliverabilityTestReportsCommandOutput extends ListDeliverabilityTestReportsResponse, __MetadataBearer {
 }
-/**
- * <p>Show a list of the predictive inbox placement tests that you've performed, regardless of their statuses. For
- *             predictive inbox placement tests that are complete, you can use the <code>GetDeliverabilityTestReport</code>
- *             operation to view the results.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, ListDeliverabilityTestReportsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, ListDeliverabilityTestReportsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new ListDeliverabilityTestReportsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDeliverabilityTestReportsCommandInput} for command's `input` shape.
- * @see {@link ListDeliverabilityTestReportsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDeliverabilityTestReportsCommand extends $Command<ListDeliverabilityTestReportsCommandInput, ListDeliverabilityTestReportsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: ListDeliverabilityTestReportsCommandInput;
     constructor(input: ListDeliverabilityTestReportsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDeliverabilityTestReportsCommandInput, ListDeliverabilityTestReportsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ListDomainDeliverabilityCampaignsCommandInput extends ListDomai
 }
 export interface ListDomainDeliverabilityCampaignsCommandOutput extends ListDomainDeliverabilityCampaignsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieve deliverability data for all the campaigns that used a specific domain to send
- *             email during a specified time range. This data is available for a domain only if you
- *             enabled the Deliverability dashboard for the domain.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, ListDomainDeliverabilityCampaignsCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, ListDomainDeliverabilityCampaignsCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new ListDomainDeliverabilityCampaignsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDomainDeliverabilityCampaignsCommandInput} for command's `input` shape.
- * @see {@link ListDomainDeliverabilityCampaignsCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDomainDeliverabilityCampaignsCommand extends $Command<ListDomainDeliverabilityCampaignsCommandInput, ListDomainDeliverabilityCampaignsCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: ListDomainDeliverabilityCampaignsCommandInput;
     constructor(input: ListDomainDeliverabilityCampaignsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDomainDeliverabilityCampaignsCommandInput, ListDomainDeliverabilityCampaignsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface ListEmailIdentitiesCommandInput extends ListEmailIdentitiesRequ
 }
 export interface ListEmailIdentitiesCommandOutput extends ListEmailIdentitiesResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of all of the email identities that are associated with your Amazon Web Services
- *             account. An identity can be either an email address or a domain. This operation returns
- *             identities that are verified as well as those that aren't. This operation returns
- *             identities that are associated with Amazon SES and Amazon Pinpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SESv2Client, ListEmailIdentitiesCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, ListEmailIdentitiesCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new ListEmailIdentitiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEmailIdentitiesCommandInput} for command's `input` shape.
- * @see {@link ListEmailIdentitiesCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListEmailIdentitiesCommand extends $Command<ListEmailIdentitiesCommandInput, ListEmailIdentitiesCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: ListEmailIdentitiesCommandInput;
     constructor(input: ListEmailIdentitiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEmailIdentitiesCommandInput, ListEmailIdentitiesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface ListEmailTemplatesCommandInput extends ListEmailTemplatesReques
 }
 export interface ListEmailTemplatesCommandOutput extends ListEmailTemplatesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the email templates present in your Amazon SES account in the current Amazon Web Services
- *             Region.</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, ListEmailTemplatesCommand } from "@aws-sdk/client-sesv2"; // ES Modules import
- * // const { SESv2Client, ListEmailTemplatesCommand } = require("@aws-sdk/client-sesv2"); // CommonJS import
- * const client = new SESv2Client(config);
- * const command = new ListEmailTemplatesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEmailTemplatesCommandInput} for command's `input` shape.
- * @see {@link ListEmailTemplatesCommandOutput} for command's `response` shape.
- * @see {@link SESv2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListEmailTemplatesCommand extends $Command<ListEmailTemplatesCommandInput, ListEmailTemplatesCommandOutput, SESv2ClientResolvedConfig> {
     readonly input: ListEmailTemplatesCommandInput;
     constructor(input: ListEmailTemplatesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SESv2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEmailTemplatesCommandInput, ListEmailTemplatesCommandOutput>;
     private serialize;
     private deserialize;