@aws-sdk/client-pinpoint 3.36.0 → 3.39.0

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface GetSegmentVersionCommandInput extends GetSegmentVersionRequest
 }
 export interface GetSegmentVersionCommandOutput extends GetSegmentVersionResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves information about the configuration, dimension, and other settings for a specific version of a segment that's associated with an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, GetSegmentVersionCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, GetSegmentVersionCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new GetSegmentVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSegmentVersionCommandInput} for command's `input` shape.
- * @see {@link GetSegmentVersionCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSegmentVersionCommand extends $Command<GetSegmentVersionCommandInput, GetSegmentVersionCommandOutput, PinpointClientResolvedConfig> {
     readonly input: GetSegmentVersionCommandInput;
     constructor(input: GetSegmentVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSegmentVersionCommandInput, GetSegmentVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetSegmentVersionsCommandInput extends GetSegmentVersionsReques
 }
 export interface GetSegmentVersionsCommandOutput extends GetSegmentVersionsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves information about the configuration, dimension, and other settings for all the versions of a specific segment that's associated with an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, GetSegmentVersionsCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, GetSegmentVersionsCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new GetSegmentVersionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSegmentVersionsCommandInput} for command's `input` shape.
- * @see {@link GetSegmentVersionsCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSegmentVersionsCommand extends $Command<GetSegmentVersionsCommandInput, GetSegmentVersionsCommandOutput, PinpointClientResolvedConfig> {
     readonly input: GetSegmentVersionsCommandInput;
     constructor(input: GetSegmentVersionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSegmentVersionsCommandInput, GetSegmentVersionsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface GetUserEndpointsCommandInput extends GetUserEndpointsRequest {
 }
 export interface GetUserEndpointsCommandOutput extends GetUserEndpointsResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves information about 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, GetUserEndpointsCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, GetUserEndpointsCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new GetUserEndpointsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetUserEndpointsCommandInput} for command's `input` shape.
- * @see {@link GetUserEndpointsCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetUserEndpointsCommand extends $Command<GetUserEndpointsCommandInput, GetUserEndpointsCommandOutput, PinpointClientResolvedConfig> {
     readonly input: GetUserEndpointsCommandInput;
     constructor(input: GetUserEndpointsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUserEndpointsCommandInput, GetUserEndpointsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves all the tags (keys and values) that are associated with 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, ListTagsForResourceCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, ListTagsForResourceCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, PinpointClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface ListTemplatesCommandInput extends ListTemplatesRequest {
 }
 export interface ListTemplatesCommandOutput extends ListTemplatesResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves information about all the message templates that are associated with your Amazon Pinpoint account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, ListTemplatesCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, ListTemplatesCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new ListTemplatesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTemplatesCommandInput} for command's `input` shape.
- * @see {@link ListTemplatesCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTemplatesCommand extends $Command<ListTemplatesCommandInput, ListTemplatesCommandOutput, PinpointClientResolvedConfig> {
     readonly input: ListTemplatesCommandInput;
     constructor(input: ListTemplatesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTemplatesCommandInput, ListTemplatesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface PutEventStreamCommandInput extends PutEventStreamRequest {
 }
 export interface PutEventStreamCommandOutput extends PutEventStreamResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new event stream for an application or updates the settings of an existing 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, PutEventStreamCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, PutEventStreamCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new PutEventStreamCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutEventStreamCommandInput} for command's `input` shape.
- * @see {@link PutEventStreamCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutEventStreamCommand extends $Command<PutEventStreamCommandInput, PutEventStreamCommandOutput, PinpointClientResolvedConfig> {
     readonly input: PutEventStreamCommandInput;
     constructor(input: PutEventStreamCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEventStreamCommandInput, PutEventStreamCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface PutEventsCommandInput extends PutEventsRequest {
 }
 export interface PutEventsCommandOutput extends PutEventsResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new event to record for endpoints, or creates or updates endpoint data that existing events are associated with.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, PutEventsCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, PutEventsCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new PutEventsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutEventsCommandInput} for command's `input` shape.
- * @see {@link PutEventsCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutEventsCommand extends $Command<PutEventsCommandInput, PutEventsCommandOutput, PinpointClientResolvedConfig> {
     readonly input: PutEventsCommandInput;
     constructor(input: PutEventsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutEventsCommandInput, PutEventsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface RemoveAttributesCommandInput extends RemoveAttributesRequest {
 }
 export interface RemoveAttributesCommandOutput extends RemoveAttributesResponse, __MetadataBearer {
 }
-/**
- * <p>Removes one or more attributes, of the same attribute type, from all the endpoints that are associated with an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PinpointClient, RemoveAttributesCommand } from "@aws-sdk/client-pinpoint"; // ES Modules import
- * // const { PinpointClient, RemoveAttributesCommand } = require("@aws-sdk/client-pinpoint"); // CommonJS import
- * const client = new PinpointClient(config);
- * const command = new RemoveAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RemoveAttributesCommandInput} for command's `input` shape.
- * @see {@link RemoveAttributesCommandOutput} for command's `response` shape.
- * @see {@link PinpointClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RemoveAttributesCommand extends $Command<RemoveAttributesCommandInput, RemoveAttributesCommandOutput, PinpointClientResolvedConfig> {
     readonly input: RemoveAttributesCommandInput;
     constructor(input: RemoveAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PinpointClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveAttributesCommandInput, RemoveAttributesCommandOutput>;
     private serialize;
     private deserialize;

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

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