@aws-sdk/client-comprehend 3.35.0 → 3.38.0

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

@@ -6,29 +6,11 @@ export interface DescribeDocumentClassifierCommandInput extends DescribeDocument
 }
 export interface DescribeDocumentClassifierCommandOutput extends DescribeDocumentClassifierResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the properties associated with a document classifier.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DescribeDocumentClassifierCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DescribeDocumentClassifierCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DescribeDocumentClassifierCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDocumentClassifierCommandInput} for command's `input` shape.
- * @see {@link DescribeDocumentClassifierCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDocumentClassifierCommand extends $Command<DescribeDocumentClassifierCommandInput, DescribeDocumentClassifierCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DescribeDocumentClassifierCommandInput;
     constructor(input: DescribeDocumentClassifierCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDocumentClassifierCommandInput, DescribeDocumentClassifierCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeDominantLanguageDetectionJobCommandInput extends Descri
 }
 export interface DescribeDominantLanguageDetectionJobCommandOutput extends DescribeDominantLanguageDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the properties associated with a dominant language detection job. Use this operation
- *       to get the status of a detection job.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DescribeDominantLanguageDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DescribeDominantLanguageDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DescribeDominantLanguageDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDominantLanguageDetectionJobCommandInput} for command's `input` shape.
- * @see {@link DescribeDominantLanguageDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDominantLanguageDetectionJobCommand extends $Command<DescribeDominantLanguageDetectionJobCommandInput, DescribeDominantLanguageDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DescribeDominantLanguageDetectionJobCommandInput;
     constructor(input: DescribeDominantLanguageDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDominantLanguageDetectionJobCommandInput, DescribeDominantLanguageDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeEndpointCommandInput extends DescribeEndpointRequest {
 }
 export interface DescribeEndpointCommandOutput extends DescribeEndpointResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the properties associated with a specific endpoint. Use this operation to get the
- *       status of an endpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DescribeEndpointCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DescribeEndpointCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DescribeEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEndpointCommandInput} for command's `input` shape.
- * @see {@link DescribeEndpointCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEndpointCommand extends $Command<DescribeEndpointCommandInput, DescribeEndpointCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DescribeEndpointCommandInput;
     constructor(input: DescribeEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEndpointCommandInput, DescribeEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeEntitiesDetectionJobCommandInput extends DescribeEntiti
 }
 export interface DescribeEntitiesDetectionJobCommandOutput extends DescribeEntitiesDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the properties associated with an entities detection job. Use this operation to get
- *       the status of a detection job.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DescribeEntitiesDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DescribeEntitiesDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DescribeEntitiesDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEntitiesDetectionJobCommandInput} for command's `input` shape.
- * @see {@link DescribeEntitiesDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEntitiesDetectionJobCommand extends $Command<DescribeEntitiesDetectionJobCommandInput, DescribeEntitiesDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DescribeEntitiesDetectionJobCommandInput;
     constructor(input: DescribeEntitiesDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEntitiesDetectionJobCommandInput, DescribeEntitiesDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeEntityRecognizerCommandInput extends DescribeEntityReco
 }
 export interface DescribeEntityRecognizerCommandOutput extends DescribeEntityRecognizerResponse, __MetadataBearer {
 }
-/**
- * <p>Provides details about an entity recognizer including status, S3 buckets containing
- *       training data, recognizer metadata, metrics, and so on.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DescribeEntityRecognizerCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DescribeEntityRecognizerCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DescribeEntityRecognizerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEntityRecognizerCommandInput} for command's `input` shape.
- * @see {@link DescribeEntityRecognizerCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEntityRecognizerCommand extends $Command<DescribeEntityRecognizerCommandInput, DescribeEntityRecognizerCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DescribeEntityRecognizerCommandInput;
     constructor(input: DescribeEntityRecognizerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEntityRecognizerCommandInput, DescribeEntityRecognizerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeEventsDetectionJobCommandInput extends DescribeEventsDe
 }
 export interface DescribeEventsDetectionJobCommandOutput extends DescribeEventsDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the status and details of an events detection job.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DescribeEventsDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DescribeEventsDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DescribeEventsDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEventsDetectionJobCommandInput} for command's `input` shape.
- * @see {@link DescribeEventsDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEventsDetectionJobCommand extends $Command<DescribeEventsDetectionJobCommandInput, DescribeEventsDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DescribeEventsDetectionJobCommandInput;
     constructor(input: DescribeEventsDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventsDetectionJobCommandInput, DescribeEventsDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeKeyPhrasesDetectionJobCommandInput extends DescribeKeyP
 }
 export interface DescribeKeyPhrasesDetectionJobCommandOutput extends DescribeKeyPhrasesDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the properties associated with a key phrases detection job. Use this operation to get
- *       the status of a detection job.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DescribeKeyPhrasesDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DescribeKeyPhrasesDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DescribeKeyPhrasesDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeKeyPhrasesDetectionJobCommandInput} for command's `input` shape.
- * @see {@link DescribeKeyPhrasesDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeKeyPhrasesDetectionJobCommand extends $Command<DescribeKeyPhrasesDetectionJobCommandInput, DescribeKeyPhrasesDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DescribeKeyPhrasesDetectionJobCommandInput;
     constructor(input: DescribeKeyPhrasesDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeKeyPhrasesDetectionJobCommandInput, DescribeKeyPhrasesDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribePiiEntitiesDetectionJobCommandInput extends DescribePii
 }
 export interface DescribePiiEntitiesDetectionJobCommandOutput extends DescribePiiEntitiesDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the properties associated with a PII entities detection job. For example, you can use
- *       this operation to get the job status.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DescribePiiEntitiesDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DescribePiiEntitiesDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DescribePiiEntitiesDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribePiiEntitiesDetectionJobCommandInput} for command's `input` shape.
- * @see {@link DescribePiiEntitiesDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribePiiEntitiesDetectionJobCommand extends $Command<DescribePiiEntitiesDetectionJobCommandInput, DescribePiiEntitiesDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DescribePiiEntitiesDetectionJobCommandInput;
     constructor(input: DescribePiiEntitiesDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePiiEntitiesDetectionJobCommandInput, DescribePiiEntitiesDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeSentimentDetectionJobCommandInput extends DescribeSenti
 }
 export interface DescribeSentimentDetectionJobCommandOutput extends DescribeSentimentDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the properties associated with a sentiment detection job. Use this operation to get
- *       the status of a detection job.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DescribeSentimentDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DescribeSentimentDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DescribeSentimentDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSentimentDetectionJobCommandInput} for command's `input` shape.
- * @see {@link DescribeSentimentDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSentimentDetectionJobCommand extends $Command<DescribeSentimentDetectionJobCommandInput, DescribeSentimentDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DescribeSentimentDetectionJobCommandInput;
     constructor(input: DescribeSentimentDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSentimentDetectionJobCommandInput, DescribeSentimentDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeTopicsDetectionJobCommandInput extends DescribeTopicsDe
 }
 export interface DescribeTopicsDetectionJobCommandOutput extends DescribeTopicsDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the properties associated with a topic detection job. Use this operation to get
- *       the status of a detection job.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DescribeTopicsDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DescribeTopicsDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DescribeTopicsDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTopicsDetectionJobCommandInput} for command's `input` shape.
- * @see {@link DescribeTopicsDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeTopicsDetectionJobCommand extends $Command<DescribeTopicsDetectionJobCommandInput, DescribeTopicsDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DescribeTopicsDetectionJobCommandInput;
     constructor(input: DescribeTopicsDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTopicsDetectionJobCommandInput, DescribeTopicsDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DetectDominantLanguageCommandInput extends DetectDominantLangua
 }
 export interface DetectDominantLanguageCommandOutput extends DetectDominantLanguageResponse, __MetadataBearer {
 }
-/**
- * <p>Determines the dominant language of the input text. For a list of languages that Amazon
- *       Comprehend can detect, see <a href="https://docs.aws.amazon.com/comprehend/latest/dg/how-languages.html">Amazon Comprehend Supported Languages</a>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DetectDominantLanguageCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DetectDominantLanguageCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DetectDominantLanguageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectDominantLanguageCommandInput} for command's `input` shape.
- * @see {@link DetectDominantLanguageCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectDominantLanguageCommand extends $Command<DetectDominantLanguageCommandInput, DetectDominantLanguageCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DetectDominantLanguageCommandInput;
     constructor(input: DetectDominantLanguageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectDominantLanguageCommandInput, DetectDominantLanguageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DetectEntitiesCommandInput extends DetectEntitiesRequest {
 }
 export interface DetectEntitiesCommandOutput extends DetectEntitiesResponse, __MetadataBearer {
 }
-/**
- * <p>Inspects text for named entities, and returns information about them. For more
- *       information, about named entities, see <a>how-entities</a>. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DetectEntitiesCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DetectEntitiesCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DetectEntitiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectEntitiesCommandInput} for command's `input` shape.
- * @see {@link DetectEntitiesCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectEntitiesCommand extends $Command<DetectEntitiesCommandInput, DetectEntitiesCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DetectEntitiesCommandInput;
     constructor(input: DetectEntitiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectEntitiesCommandInput, DetectEntitiesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DetectKeyPhrasesCommandInput extends DetectKeyPhrasesRequest {
 }
 export interface DetectKeyPhrasesCommandOutput extends DetectKeyPhrasesResponse, __MetadataBearer {
 }
-/**
- * <p>Detects the key noun phrases found in the text. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DetectKeyPhrasesCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DetectKeyPhrasesCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DetectKeyPhrasesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectKeyPhrasesCommandInput} for command's `input` shape.
- * @see {@link DetectKeyPhrasesCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectKeyPhrasesCommand extends $Command<DetectKeyPhrasesCommandInput, DetectKeyPhrasesCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DetectKeyPhrasesCommandInput;
     constructor(input: DetectKeyPhrasesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectKeyPhrasesCommandInput, DetectKeyPhrasesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DetectPiiEntitiesCommandInput extends DetectPiiEntitiesRequest
 }
 export interface DetectPiiEntitiesCommandOutput extends DetectPiiEntitiesResponse, __MetadataBearer {
 }
-/**
- * <p>Inspects the input text for entities that contain personally identifiable information
- *       (PII) and returns information about them.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DetectPiiEntitiesCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DetectPiiEntitiesCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DetectPiiEntitiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectPiiEntitiesCommandInput} for command's `input` shape.
- * @see {@link DetectPiiEntitiesCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectPiiEntitiesCommand extends $Command<DetectPiiEntitiesCommandInput, DetectPiiEntitiesCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DetectPiiEntitiesCommandInput;
     constructor(input: DetectPiiEntitiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectPiiEntitiesCommandInput, DetectPiiEntitiesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DetectSentimentCommandInput extends DetectSentimentRequest {
 }
 export interface DetectSentimentCommandOutput extends DetectSentimentResponse, __MetadataBearer {
 }
-/**
- * <p>Inspects text and returns an inference of the prevailing sentiment
- *         (<code>POSITIVE</code>, <code>NEUTRAL</code>, <code>MIXED</code>, or <code>NEGATIVE</code>). </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DetectSentimentCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DetectSentimentCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DetectSentimentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectSentimentCommandInput} for command's `input` shape.
- * @see {@link DetectSentimentCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectSentimentCommand extends $Command<DetectSentimentCommandInput, DetectSentimentCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DetectSentimentCommandInput;
     constructor(input: DetectSentimentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectSentimentCommandInput, DetectSentimentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DetectSyntaxCommandInput extends DetectSyntaxRequest {
 }
 export interface DetectSyntaxCommandOutput extends DetectSyntaxResponse, __MetadataBearer {
 }
-/**
- * <p>Inspects text for syntax and the part of speech of words in the document. For more
- *       information, <a>how-syntax</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DetectSyntaxCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DetectSyntaxCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DetectSyntaxCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DetectSyntaxCommandInput} for command's `input` shape.
- * @see {@link DetectSyntaxCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DetectSyntaxCommand extends $Command<DetectSyntaxCommandInput, DetectSyntaxCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DetectSyntaxCommandInput;
     constructor(input: DetectSyntaxCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DetectSyntaxCommandInput, DetectSyntaxCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListDocumentClassificationJobsCommandInput extends ListDocument
 }
 export interface ListDocumentClassificationJobsCommandOutput extends ListDocumentClassificationJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of the documentation classification jobs that you have submitted.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, ListDocumentClassificationJobsCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListDocumentClassificationJobsCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListDocumentClassificationJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDocumentClassificationJobsCommandInput} for command's `input` shape.
- * @see {@link ListDocumentClassificationJobsCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDocumentClassificationJobsCommand extends $Command<ListDocumentClassificationJobsCommandInput, ListDocumentClassificationJobsCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListDocumentClassificationJobsCommandInput;
     constructor(input: ListDocumentClassificationJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDocumentClassificationJobsCommandInput, ListDocumentClassificationJobsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListDocumentClassifierSummariesCommandInput extends ListDocumen
 }
 export interface ListDocumentClassifierSummariesCommandOutput extends ListDocumentClassifierSummariesResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of summaries of the document classifiers that you have created</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, ListDocumentClassifierSummariesCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListDocumentClassifierSummariesCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListDocumentClassifierSummariesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDocumentClassifierSummariesCommandInput} for command's `input` shape.
- * @see {@link ListDocumentClassifierSummariesCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDocumentClassifierSummariesCommand extends $Command<ListDocumentClassifierSummariesCommandInput, ListDocumentClassifierSummariesCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListDocumentClassifierSummariesCommandInput;
     constructor(input: ListDocumentClassifierSummariesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDocumentClassifierSummariesCommandInput, ListDocumentClassifierSummariesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListDocumentClassifiersCommandInput extends ListDocumentClassif
 }
 export interface ListDocumentClassifiersCommandOutput extends ListDocumentClassifiersResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of the document classifiers that you have created.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, ListDocumentClassifiersCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListDocumentClassifiersCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListDocumentClassifiersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDocumentClassifiersCommandInput} for command's `input` shape.
- * @see {@link ListDocumentClassifiersCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDocumentClassifiersCommand extends $Command<ListDocumentClassifiersCommandInput, ListDocumentClassifiersCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListDocumentClassifiersCommandInput;
     constructor(input: ListDocumentClassifiersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDocumentClassifiersCommandInput, ListDocumentClassifiersCommandOutput>;
     private serialize;
     private deserialize;