@aws-sdk/client-pinpoint-email 3.35.0 → 3.38.0

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

@@ -6,35 +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>In Amazon Pinpoint, <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 { PinpointEmailClient, GetConfigurationSetEventDestinationsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, GetConfigurationSetEventDestinationsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetConfigurationSetEventDestinationsCommand extends $Command<GetConfigurationSetEventDestinationsCommandInput, GetConfigurationSetEventDestinationsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: GetConfigurationSetEventDestinationsCommandInput;
     constructor(input: GetConfigurationSetEventDestinationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConfigurationSetEventDestinationsCommandInput, GetConfigurationSetEventDestinationsCommandOutput>;
     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 { PinpointEmailClient, GetDedicatedIpCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, GetDedicatedIpCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDedicatedIpCommand extends $Command<GetDedicatedIpCommandInput, GetDedicatedIpCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: GetDedicatedIpCommandInput;
     constructor(input: GetDedicatedIpCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, 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 Pinpoint
- *             account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointEmailClient, GetDedicatedIpsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, GetDedicatedIpsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDedicatedIpsCommand extends $Command<GetDedicatedIpsCommandInput, GetDedicatedIpsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: GetDedicatedIpsCommandInput;
     constructor(input: GetDedicatedIpsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDedicatedIpsCommandInput, GetDedicatedIpsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +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 Amazon Pinpoint 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 using Amazon Pinpoint. 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 Pinpoint. For more information about the
- *             features and cost of a Deliverability dashboard subscription, see <a href="http://aws.amazon.com/pinpoint/pricing/">Amazon Pinpoint Pricing</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointEmailClient, GetDeliverabilityDashboardOptionsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, GetDeliverabilityDashboardOptionsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDeliverabilityDashboardOptionsCommand extends $Command<GetDeliverabilityDashboardOptionsCommandInput, GetDeliverabilityDashboardOptionsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: GetDeliverabilityDashboardOptionsCommandInput;
     constructor(input: GetDeliverabilityDashboardOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, 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 { PinpointEmailClient, GetDeliverabilityTestReportCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, GetDeliverabilityTestReportCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDeliverabilityTestReportCommand extends $Command<GetDeliverabilityTestReportCommandInput, GetDeliverabilityTestReportCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: GetDeliverabilityTestReportCommandInput;
     constructor(input: GetDeliverabilityTestReportCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeliverabilityTestReportCommandInput, GetDeliverabilityTestReportCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +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 (<code>PutDeliverabilityDashboardOption</code>
- *             operation).</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointEmailClient, GetDomainDeliverabilityCampaignCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, GetDomainDeliverabilityCampaignCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDomainDeliverabilityCampaignCommand extends $Command<GetDomainDeliverabilityCampaignCommandInput, GetDomainDeliverabilityCampaignCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: GetDomainDeliverabilityCampaignCommandInput;
     constructor(input: GetDomainDeliverabilityCampaignCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, 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 { PinpointEmailClient, GetDomainStatisticsReportCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, GetDomainStatisticsReportCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDomainStatisticsReportCommand extends $Command<GetDomainStatisticsReportCommandInput, GetDomainStatisticsReportCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: GetDomainStatisticsReportCommandInput;
     constructor(input: GetDomainStatisticsReportCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, 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 associated with your Amazon Pinpoint account,
- *             including the identity's verification status, 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 { PinpointEmailClient, GetEmailIdentityCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, GetEmailIdentityCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetEmailIdentityCommand extends $Command<GetEmailIdentityCommandInput, GetEmailIdentityCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: GetEmailIdentityCommandInput;
     constructor(input: GetEmailIdentityCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEmailIdentityCommandInput, GetEmailIdentityCommandOutput>;
     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 Amazon Pinpoint account in the current
- *             region.</p>
- *         <p>In Amazon Pinpoint, <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 { PinpointEmailClient, ListConfigurationSetsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, ListConfigurationSetsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListConfigurationSetsCommand extends $Command<ListConfigurationSetsCommandInput, ListConfigurationSetsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: ListConfigurationSetsCommandInput;
     constructor(input: ListConfigurationSetsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConfigurationSetsCommandInput, ListConfigurationSetsCommandOutput>;
     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 Pinpoint account in the current
- *             AWS Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointEmailClient, ListDedicatedIpPoolsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, ListDedicatedIpPoolsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDedicatedIpPoolsCommand extends $Command<ListDedicatedIpPoolsCommandInput, ListDedicatedIpPoolsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: ListDedicatedIpPoolsCommandInput;
     constructor(input: ListDedicatedIpPoolsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, 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 { PinpointEmailClient, ListDeliverabilityTestReportsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, ListDeliverabilityTestReportsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDeliverabilityTestReportsCommand extends $Command<ListDeliverabilityTestReportsCommandInput, ListDeliverabilityTestReportsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: ListDeliverabilityTestReportsCommandInput;
     constructor(input: ListDeliverabilityTestReportsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDeliverabilityTestReportsCommandInput, ListDeliverabilityTestReportsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +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 (<code>PutDeliverabilityDashboardOption</code> operation)
- *             for the domain.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointEmailClient, ListDomainDeliverabilityCampaignsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, ListDomainDeliverabilityCampaignsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDomainDeliverabilityCampaignsCommand extends $Command<ListDomainDeliverabilityCampaignsCommandInput, ListDomainDeliverabilityCampaignsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: ListDomainDeliverabilityCampaignsCommandInput;
     constructor(input: ListDomainDeliverabilityCampaignsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDomainDeliverabilityCampaignsCommandInput, ListDomainDeliverabilityCampaignsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +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 Pinpoint
- *             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.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointEmailClient, ListEmailIdentitiesCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, ListEmailIdentitiesCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListEmailIdentitiesCommand extends $Command<ListEmailIdentitiesCommandInput, ListEmailIdentitiesCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: ListEmailIdentitiesCommandInput;
     constructor(input: ListEmailIdentitiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEmailIdentitiesCommandInput, ListEmailIdentitiesCommandOutput>;
     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 in Amazon Pinpoint. 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 { PinpointEmailClient, ListTagsForResourceCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, ListTagsForResourceCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, 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 { PinpointEmailClient, PutAccountDedicatedIpWarmupAttributesCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, PutAccountDedicatedIpWarmupAttributesCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutAccountDedicatedIpWarmupAttributesCommand extends $Command<PutAccountDedicatedIpWarmupAttributesCommandInput, PutAccountDedicatedIpWarmupAttributesCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: PutAccountDedicatedIpWarmupAttributesCommandInput;
     constructor(input: PutAccountDedicatedIpWarmupAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAccountDedicatedIpWarmupAttributesCommandInput, PutAccountDedicatedIpWarmupAttributesCommandOutput>;
     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 { PinpointEmailClient, PutAccountSendingAttributesCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, PutAccountSendingAttributesCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutAccountSendingAttributesCommand extends $Command<PutAccountSendingAttributesCommandInput, PutAccountSendingAttributesCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: PutAccountSendingAttributesCommandInput;
     constructor(input: PutAccountSendingAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutAccountSendingAttributesCommandInput, PutAccountSendingAttributesCommandOutput>;
     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 { PinpointEmailClient, PutConfigurationSetDeliveryOptionsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, PutConfigurationSetDeliveryOptionsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutConfigurationSetDeliveryOptionsCommand extends $Command<PutConfigurationSetDeliveryOptionsCommandInput, PutConfigurationSetDeliveryOptionsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: PutConfigurationSetDeliveryOptionsCommandInput;
     constructor(input: PutConfigurationSetDeliveryOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, 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 AWS Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointEmailClient, PutConfigurationSetReputationOptionsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, PutConfigurationSetReputationOptionsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutConfigurationSetReputationOptionsCommand extends $Command<PutConfigurationSetReputationOptionsCommandInput, PutConfigurationSetReputationOptionsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: PutConfigurationSetReputationOptionsCommandInput;
     constructor(input: PutConfigurationSetReputationOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutConfigurationSetReputationOptionsCommandInput, PutConfigurationSetReputationOptionsCommandOutput>;
     private serialize;
     private deserialize;