@aws-sdk/client-pinpoint 3.36.0 → 3.39.0

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

@@ -6,29 +6,11 @@ export interface SendUsersMessagesCommandInput extends SendUsersMessagesRequest
 }
 export interface SendUsersMessagesCommandOutput extends SendUsersMessagesResponse, __MetadataBearer {
 }
-/**
- * <p>Creates and sends a message to a list of users.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, SendUsersMessagesCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, SendUsersMessagesCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new SendUsersMessagesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SendUsersMessagesCommandInput} for command's `input` shape.
- * @see {@link SendUsersMessagesCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SendUsersMessagesCommand extends $Command<SendUsersMessagesCommandInput, SendUsersMessagesCommandOutput, PinpointClientResolvedConfig> {
     readonly input: SendUsersMessagesCommandInput;
     constructor(input: SendUsersMessagesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SendUsersMessagesCommandInput, SendUsersMessagesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Adds one or more tags (keys and values) to an application, campaign, message template, or segment.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, TagResourceCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, TagResourceCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(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 PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, PinpointClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, 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 __MetadataBearer {
 }
-/**
- * <p>Removes one or more tags (keys and values) from an application, campaign, message template, or segment.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UntagResourceCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UntagResourceCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(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 PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateAdmChannelCommandInput extends UpdateAdmChannelRequest {
 }
 export interface UpdateAdmChannelCommandOutput extends UpdateAdmChannelResponse, __MetadataBearer {
 }
-/**
- * <p>Enables the ADM channel for an application or updates the status and settings of the ADM channel for an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateAdmChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateAdmChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateAdmChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAdmChannelCommandInput} for command's `input` shape.
- * @see {@link UpdateAdmChannelCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateAdmChannelCommand extends $Command<UpdateAdmChannelCommandInput, UpdateAdmChannelCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateAdmChannelCommandInput;
     constructor(input: UpdateAdmChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAdmChannelCommandInput, UpdateAdmChannelCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateApnsChannelCommandInput extends UpdateApnsChannelRequest
 }
 export interface UpdateApnsChannelCommandOutput extends UpdateApnsChannelResponse, __MetadataBearer {
 }
-/**
- * <p>Enables the APNs channel for an application or updates the status and settings of the APNs channel for an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateApnsChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateApnsChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateApnsChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateApnsChannelCommandInput} for command's `input` shape.
- * @see {@link UpdateApnsChannelCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateApnsChannelCommand extends $Command<UpdateApnsChannelCommandInput, UpdateApnsChannelCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateApnsChannelCommandInput;
     constructor(input: UpdateApnsChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApnsChannelCommandInput, UpdateApnsChannelCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateApnsSandboxChannelCommandInput extends UpdateApnsSandboxC
 }
 export interface UpdateApnsSandboxChannelCommandOutput extends UpdateApnsSandboxChannelResponse, __MetadataBearer {
 }
-/**
- * <p>Enables the APNs sandbox channel for an application or updates the status and settings of the APNs sandbox channel for an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateApnsSandboxChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateApnsSandboxChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateApnsSandboxChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateApnsSandboxChannelCommandInput} for command's `input` shape.
- * @see {@link UpdateApnsSandboxChannelCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateApnsSandboxChannelCommand extends $Command<UpdateApnsSandboxChannelCommandInput, UpdateApnsSandboxChannelCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateApnsSandboxChannelCommandInput;
     constructor(input: UpdateApnsSandboxChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApnsSandboxChannelCommandInput, UpdateApnsSandboxChannelCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateApnsVoipChannelCommandInput extends UpdateApnsVoipChannel
 }
 export interface UpdateApnsVoipChannelCommandOutput extends UpdateApnsVoipChannelResponse, __MetadataBearer {
 }
-/**
- * <p>Enables the APNs VoIP channel for an application or updates the status and settings of the APNs VoIP channel for an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateApnsVoipChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateApnsVoipChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateApnsVoipChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateApnsVoipChannelCommandInput} for command's `input` shape.
- * @see {@link UpdateApnsVoipChannelCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateApnsVoipChannelCommand extends $Command<UpdateApnsVoipChannelCommandInput, UpdateApnsVoipChannelCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateApnsVoipChannelCommandInput;
     constructor(input: UpdateApnsVoipChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApnsVoipChannelCommandInput, UpdateApnsVoipChannelCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateApnsVoipSandboxChannelCommandInput extends UpdateApnsVoip
 }
 export interface UpdateApnsVoipSandboxChannelCommandOutput extends UpdateApnsVoipSandboxChannelResponse, __MetadataBearer {
 }
-/**
- * <p>Enables the APNs VoIP sandbox channel for an application or updates the status and settings of the APNs VoIP sandbox channel for an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateApnsVoipSandboxChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateApnsVoipSandboxChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateApnsVoipSandboxChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateApnsVoipSandboxChannelCommandInput} for command's `input` shape.
- * @see {@link UpdateApnsVoipSandboxChannelCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateApnsVoipSandboxChannelCommand extends $Command<UpdateApnsVoipSandboxChannelCommandInput, UpdateApnsVoipSandboxChannelCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateApnsVoipSandboxChannelCommandInput;
     constructor(input: UpdateApnsVoipSandboxChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApnsVoipSandboxChannelCommandInput, UpdateApnsVoipSandboxChannelCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface UpdateBaiduChannelCommandInput extends UpdateBaiduChannelReques
 }
 export interface UpdateBaiduChannelCommandOutput extends UpdateBaiduChannelResponse, __MetadataBearer {
 }
-/**
- * <p>Enables the Baidu channel for an application or updates the status and settings of the Baidu channel for an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateBaiduChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateBaiduChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateBaiduChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateBaiduChannelCommandInput} for command's `input` shape.
- * @see {@link UpdateBaiduChannelCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateBaiduChannelCommand extends $Command<UpdateBaiduChannelCommandInput, UpdateBaiduChannelCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateBaiduChannelCommandInput;
     constructor(input: UpdateBaiduChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateBaiduChannelCommandInput, UpdateBaiduChannelCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface UpdateEmailChannelCommandInput extends UpdateEmailChannelReques
 }
 export interface UpdateEmailChannelCommandOutput extends UpdateEmailChannelResponse, __MetadataBearer {
 }
-/**
- * <p>Enables the email channel for an application or updates the status and settings of the email channel for an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateEmailChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateEmailChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateEmailChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateEmailChannelCommandInput} for command's `input` shape.
- * @see {@link UpdateEmailChannelCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateEmailChannelCommand extends $Command<UpdateEmailChannelCommandInput, UpdateEmailChannelCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateEmailChannelCommandInput;
     constructor(input: UpdateEmailChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEmailChannelCommandInput, UpdateEmailChannelCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateEmailTemplateCommandInput extends UpdateEmailTemplateRequ
 }
 export interface UpdateEmailTemplateCommandOutput extends UpdateEmailTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Updates an existing message template for messages that are sent through the email channel.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateEmailTemplateCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateEmailTemplateCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateEmailTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateEmailTemplateCommandInput} for command's `input` shape.
- * @see {@link UpdateEmailTemplateCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateEmailTemplateCommand extends $Command<UpdateEmailTemplateCommandInput, UpdateEmailTemplateCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateEmailTemplateCommandInput;
     constructor(input: UpdateEmailTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEmailTemplateCommandInput, UpdateEmailTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateEndpointCommandInput extends UpdateEndpointRequest {
 }
 export interface UpdateEndpointCommandOutput extends UpdateEndpointResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new endpoint for an application or updates the settings and attributes of an existing endpoint for an application. You can also use this operation to define custom attributes for an endpoint. If an update includes one or more values for a custom attribute, Amazon Pinpoint replaces (overwrites) any existing values with the new values.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateEndpointCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateEndpointCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateEndpointCommandInput} for command's `input` shape.
- * @see {@link UpdateEndpointCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateEndpointCommand extends $Command<UpdateEndpointCommandInput, UpdateEndpointCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateEndpointCommandInput;
     constructor(input: UpdateEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEndpointCommandInput, UpdateEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateEndpointsBatchCommandInput extends UpdateEndpointsBatchRe
 }
 export interface UpdateEndpointsBatchCommandOutput extends UpdateEndpointsBatchResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new batch of endpoints for an application or updates the settings and attributes of a batch of existing endpoints for an application. You can also use this operation to define custom attributes for a batch of endpoints. If an update includes one or more values for a custom attribute, Amazon Pinpoint replaces (overwrites) any existing values with the new values.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateEndpointsBatchCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateEndpointsBatchCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateEndpointsBatchCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateEndpointsBatchCommandInput} for command's `input` shape.
- * @see {@link UpdateEndpointsBatchCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateEndpointsBatchCommand extends $Command<UpdateEndpointsBatchCommandInput, UpdateEndpointsBatchCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateEndpointsBatchCommandInput;
     constructor(input: UpdateEndpointsBatchCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEndpointsBatchCommandInput, UpdateEndpointsBatchCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateGcmChannelCommandInput extends UpdateGcmChannelRequest {
 }
 export interface UpdateGcmChannelCommandOutput extends UpdateGcmChannelResponse, __MetadataBearer {
 }
-/**
- * <p>Enables the GCM channel for an application or updates the status and settings of the GCM channel for an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateGcmChannelCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateGcmChannelCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateGcmChannelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateGcmChannelCommandInput} for command's `input` shape.
- * @see {@link UpdateGcmChannelCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateGcmChannelCommand extends $Command<UpdateGcmChannelCommandInput, UpdateGcmChannelCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateGcmChannelCommandInput;
     constructor(input: UpdateGcmChannelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateGcmChannelCommandInput, UpdateGcmChannelCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateInAppTemplateCommandInput extends UpdateInAppTemplateRequ
 }
 export interface UpdateInAppTemplateCommandOutput extends UpdateInAppTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Updates an existing message template for messages sent through the in-app message channel.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, UpdateInAppTemplateCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, UpdateInAppTemplateCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new UpdateInAppTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateInAppTemplateCommandInput} for command's `input` shape.
- * @see {@link UpdateInAppTemplateCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateInAppTemplateCommand extends $Command<UpdateInAppTemplateCommandInput, UpdateInAppTemplateCommandOutput, PinpointClientResolvedConfig> {
     readonly input: UpdateInAppTemplateCommandInput;
     constructor(input: UpdateInAppTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateInAppTemplateCommandInput, UpdateInAppTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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