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

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 AWS Region.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointEmailClient, PutConfigurationSetSendingOptionsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, PutConfigurationSetSendingOptionsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutConfigurationSetSendingOptionsCommand extends $Command<PutConfigurationSetSendingOptionsCommandInput, PutConfigurationSetSendingOptionsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: PutConfigurationSetSendingOptionsCommandInput;
     constructor(input: PutConfigurationSetSendingOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutConfigurationSetSendingOptionsCommandInput, PutConfigurationSetSendingOptionsCommandOutput>;
     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 using Amazon Pinpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointEmailClient, PutConfigurationSetTrackingOptionsCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, PutConfigurationSetTrackingOptionsCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutConfigurationSetTrackingOptionsCommand extends $Command<PutConfigurationSetTrackingOptionsCommandInput, PutConfigurationSetTrackingOptionsCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: PutConfigurationSetTrackingOptionsCommandInput;
     constructor(input: PutConfigurationSetTrackingOptionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, 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 Pinpoint 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 { PinpointEmailClient, PutDedicatedIpInPoolCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, PutDedicatedIpInPoolCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutDedicatedIpInPoolCommand extends $Command<PutDedicatedIpInPoolCommandInput, PutDedicatedIpInPoolCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: PutDedicatedIpInPoolCommandInput;
     constructor(input: PutDedicatedIpInPoolCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, 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 { PinpointEmailClient, PutDedicatedIpWarmupAttributesCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, PutDedicatedIpWarmupAttributesCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutDedicatedIpWarmupAttributesCommand extends $Command<PutDedicatedIpWarmupAttributesCommandInput, PutDedicatedIpWarmupAttributesCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: PutDedicatedIpWarmupAttributesCommandInput;
     constructor(input: PutDedicatedIpWarmupAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, 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 for your Amazon Pinpoint account. When you enable the
- *             Deliverability dashboard, 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, PutDeliverabilityDashboardOptionCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, PutDeliverabilityDashboardOptionCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutDeliverabilityDashboardOptionCommand extends $Command<PutDeliverabilityDashboardOptionCommandInput, PutDeliverabilityDashboardOptionCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: PutDeliverabilityDashboardOptionCommandInput;
     constructor(input: PutDeliverabilityDashboardOptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutDeliverabilityDashboardOptionCommandInput, PutDeliverabilityDashboardOptionCommandOutput>;
     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 { PinpointEmailClient, PutEmailIdentityDkimAttributesCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, PutEmailIdentityDkimAttributesCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(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 PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutEmailIdentityDkimAttributesCommand extends $Command<PutEmailIdentityDkimAttributesCommandInput, PutEmailIdentityDkimAttributesCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: PutEmailIdentityDkimAttributesCommandInput;
     constructor(input: PutEmailIdentityDkimAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEmailIdentityDkimAttributesCommandInput, PutEmailIdentityDkimAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

@@ -6,34 +6,11 @@ export interface UpdateConfigurationSetEventDestinationCommandInput extends Upda
 }
 export interface UpdateConfigurationSetEventDestinationCommandOutput extends UpdateConfigurationSetEventDestinationResponse, __MetadataBearer {
 }
-/**
- * <p>Update the configuration of an event destination for a configuration set.</p>
- *         <p>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, UpdateConfigurationSetEventDestinationCommand } from "@aws-sdk/client-pinpoint-email"; // ES Modules import
- * // const { PinpointEmailClient, UpdateConfigurationSetEventDestinationCommand } = require("@aws-sdk/client-pinpoint-email"); // CommonJS import
- * const client = new PinpointEmailClient(config);
- * const command = new UpdateConfigurationSetEventDestinationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateConfigurationSetEventDestinationCommandInput} for command's `input` shape.
- * @see {@link UpdateConfigurationSetEventDestinationCommandOutput} for command's `response` shape.
- * @see {@link PinpointEmailClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateConfigurationSetEventDestinationCommand extends $Command<UpdateConfigurationSetEventDestinationCommandInput, UpdateConfigurationSetEventDestinationCommandOutput, PinpointEmailClientResolvedConfig> {
     readonly input: UpdateConfigurationSetEventDestinationCommandInput;
     constructor(input: UpdateConfigurationSetEventDestinationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointEmailClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConfigurationSetEventDestinationCommandInput, UpdateConfigurationSetEventDestinationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,42 @@
+export * from "./CreateConfigurationSetCommand";
+export * from "./CreateConfigurationSetEventDestinationCommand";
+export * from "./CreateDedicatedIpPoolCommand";
+export * from "./CreateDeliverabilityTestReportCommand";
+export * from "./CreateEmailIdentityCommand";
+export * from "./DeleteConfigurationSetCommand";
+export * from "./DeleteConfigurationSetEventDestinationCommand";
+export * from "./DeleteDedicatedIpPoolCommand";
+export * from "./DeleteEmailIdentityCommand";
+export * from "./GetAccountCommand";
+export * from "./GetBlacklistReportsCommand";
+export * from "./GetConfigurationSetCommand";
+export * from "./GetConfigurationSetEventDestinationsCommand";
+export * from "./GetDedicatedIpCommand";
+export * from "./GetDedicatedIpsCommand";
+export * from "./GetDeliverabilityDashboardOptionsCommand";
+export * from "./GetDeliverabilityTestReportCommand";
+export * from "./GetDomainDeliverabilityCampaignCommand";
+export * from "./GetDomainStatisticsReportCommand";
+export * from "./GetEmailIdentityCommand";
+export * from "./ListConfigurationSetsCommand";
+export * from "./ListDedicatedIpPoolsCommand";
+export * from "./ListDeliverabilityTestReportsCommand";
+export * from "./ListDomainDeliverabilityCampaignsCommand";
+export * from "./ListEmailIdentitiesCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./PutAccountDedicatedIpWarmupAttributesCommand";
+export * from "./PutAccountSendingAttributesCommand";
+export * from "./PutConfigurationSetDeliveryOptionsCommand";
+export * from "./PutConfigurationSetReputationOptionsCommand";
+export * from "./PutConfigurationSetSendingOptionsCommand";
+export * from "./PutConfigurationSetTrackingOptionsCommand";
+export * from "./PutDedicatedIpInPoolCommand";
+export * from "./PutDedicatedIpWarmupAttributesCommand";
+export * from "./PutDeliverabilityDashboardOptionCommand";
+export * from "./PutEmailIdentityDkimAttributesCommand";
+export * from "./PutEmailIdentityFeedbackAttributesCommand";
+export * from "./PutEmailIdentityMailFromAttributesCommand";
+export * from "./SendEmailCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateConfigurationSetEventDestinationCommand";

package/dist-types/ts3.4/index.d.ts

@@ -1,52 +1,5 @@
-export * from "./PinpointEmailClient";
 export * from "./PinpointEmail";
-export * from "./commands/CreateConfigurationSetCommand";
-export * from "./commands/CreateConfigurationSetEventDestinationCommand";
-export * from "./commands/CreateDedicatedIpPoolCommand";
-export * from "./commands/CreateDeliverabilityTestReportCommand";
-export * from "./commands/CreateEmailIdentityCommand";
-export * from "./commands/DeleteConfigurationSetCommand";
-export * from "./commands/DeleteConfigurationSetEventDestinationCommand";
-export * from "./commands/DeleteDedicatedIpPoolCommand";
-export * from "./commands/DeleteEmailIdentityCommand";
-export * from "./commands/GetAccountCommand";
-export * from "./commands/GetBlacklistReportsCommand";
-export * from "./commands/GetConfigurationSetCommand";
-export * from "./commands/GetConfigurationSetEventDestinationsCommand";
-export * from "./commands/GetDedicatedIpCommand";
-export * from "./commands/GetDedicatedIpsCommand";
-export * from "./pagination/GetDedicatedIpsPaginator";
-export * from "./commands/GetDeliverabilityDashboardOptionsCommand";
-export * from "./commands/GetDeliverabilityTestReportCommand";
-export * from "./commands/GetDomainDeliverabilityCampaignCommand";
-export * from "./commands/GetDomainStatisticsReportCommand";
-export * from "./commands/GetEmailIdentityCommand";
-export * from "./commands/ListConfigurationSetsCommand";
-export * from "./pagination/ListConfigurationSetsPaginator";
-export * from "./commands/ListDedicatedIpPoolsCommand";
-export * from "./pagination/ListDedicatedIpPoolsPaginator";
-export * from "./commands/ListDeliverabilityTestReportsCommand";
-export * from "./pagination/ListDeliverabilityTestReportsPaginator";
-export * from "./commands/ListDomainDeliverabilityCampaignsCommand";
-export * from "./pagination/ListDomainDeliverabilityCampaignsPaginator";
-export * from "./commands/ListEmailIdentitiesCommand";
-export * from "./pagination/ListEmailIdentitiesPaginator";
-export * from "./commands/ListTagsForResourceCommand";
-export * from "./commands/PutAccountDedicatedIpWarmupAttributesCommand";
-export * from "./commands/PutAccountSendingAttributesCommand";
-export * from "./commands/PutConfigurationSetDeliveryOptionsCommand";
-export * from "./commands/PutConfigurationSetReputationOptionsCommand";
-export * from "./commands/PutConfigurationSetSendingOptionsCommand";
-export * from "./commands/PutConfigurationSetTrackingOptionsCommand";
-export * from "./commands/PutDedicatedIpInPoolCommand";
-export * from "./commands/PutDedicatedIpWarmupAttributesCommand";
-export * from "./commands/PutDeliverabilityDashboardOptionCommand";
-export * from "./commands/PutEmailIdentityDkimAttributesCommand";
-export * from "./commands/PutEmailIdentityFeedbackAttributesCommand";
-export * from "./commands/PutEmailIdentityMailFromAttributesCommand";
-export * from "./commands/SendEmailCommand";
-export * from "./commands/TagResourceCommand";
-export * from "./commands/UntagResourceCommand";
-export * from "./commands/UpdateConfigurationSetEventDestinationCommand";
-export * from "./pagination/Interfaces";
-export * from "./models/index";
+export * from "./PinpointEmailClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";