@aws-sdk/client-pinpoint 3.36.0 → 3.39.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface DeleteEmailTemplateCommandInput extends DeleteEmailTemplateRequ
 }
 export interface DeleteEmailTemplateCommandOutput extends DeleteEmailTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a message template for messages that were 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, DeleteEmailTemplateCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, DeleteEmailTemplateCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new DeleteEmailTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEmailTemplateCommandInput} for command's `input` shape.
- * @see {@link DeleteEmailTemplateCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteEmailTemplateCommand extends $Command<DeleteEmailTemplateCommandInput, DeleteEmailTemplateCommandOutput, PinpointClientResolvedConfig> {
     readonly input: DeleteEmailTemplateCommandInput;
     constructor(input: DeleteEmailTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEmailTemplateCommandInput, DeleteEmailTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface DeleteInAppTemplateCommandInput extends DeleteInAppTemplateRequ
 }
 export interface DeleteInAppTemplateCommandOutput extends DeleteInAppTemplateResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a message template for messages sent using 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, DeleteInAppTemplateCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, DeleteInAppTemplateCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new DeleteInAppTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteInAppTemplateCommandInput} for command's `input` shape.
- * @see {@link DeleteInAppTemplateCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteInAppTemplateCommand extends $Command<DeleteInAppTemplateCommandInput, DeleteInAppTemplateCommandOutput, PinpointClientResolvedConfig> {
     readonly input: DeleteInAppTemplateCommandInput;
     constructor(input: DeleteInAppTemplateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInAppTemplateCommandInput, DeleteInAppTemplateCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface DeleteUserEndpointsCommandInput extends DeleteUserEndpointsRequ
 }
 export interface DeleteUserEndpointsCommandOutput extends DeleteUserEndpointsResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes all the endpoints that are associated with a specific user ID.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, DeleteUserEndpointsCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, DeleteUserEndpointsCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new DeleteUserEndpointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteUserEndpointsCommandInput} for command's `input` shape.
- * @see {@link DeleteUserEndpointsCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteUserEndpointsCommand extends $Command<DeleteUserEndpointsCommandInput, DeleteUserEndpointsCommandOutput, PinpointClientResolvedConfig> {
     readonly input: DeleteUserEndpointsCommandInput;
     constructor(input: DeleteUserEndpointsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteUserEndpointsCommandInput, DeleteUserEndpointsCommandOutput>;
     private serialize;
     private deserialize;