@aws-sdk/client-comprehend 3.35.0 → 3.38.0

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

@@ -6,29 +6,11 @@ export interface ListDominantLanguageDetectionJobsCommandInput extends ListDomin
 }
 export interface ListDominantLanguageDetectionJobsCommandOutput extends ListDominantLanguageDetectionJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of the dominant language detection 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, ListDominantLanguageDetectionJobsCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListDominantLanguageDetectionJobsCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListDominantLanguageDetectionJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDominantLanguageDetectionJobsCommandInput} for command's `input` shape.
- * @see {@link ListDominantLanguageDetectionJobsCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDominantLanguageDetectionJobsCommand extends $Command<ListDominantLanguageDetectionJobsCommandInput, ListDominantLanguageDetectionJobsCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListDominantLanguageDetectionJobsCommandInput;
     constructor(input: ListDominantLanguageDetectionJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDominantLanguageDetectionJobsCommandInput, ListDominantLanguageDetectionJobsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface ListEntitiesDetectionJobsCommandInput extends ListEntitiesDetec
 }
 export interface ListEntitiesDetectionJobsCommandOutput extends ListEntitiesDetectionJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of the entity detection 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, ListEntitiesDetectionJobsCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListEntitiesDetectionJobsCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListEntitiesDetectionJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEntitiesDetectionJobsCommandInput} for command's `input` shape.
- * @see {@link ListEntitiesDetectionJobsCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListEntitiesDetectionJobsCommand extends $Command<ListEntitiesDetectionJobsCommandInput, ListEntitiesDetectionJobsCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListEntitiesDetectionJobsCommandInput;
     constructor(input: ListEntitiesDetectionJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEntitiesDetectionJobsCommandInput, ListEntitiesDetectionJobsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,34 +6,11 @@ export interface ListEntityRecognizersCommandInput extends ListEntityRecognizers
 }
 export interface ListEntityRecognizersCommandOutput extends ListEntityRecognizersResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of the properties of all entity recognizers that you created, including
- *       recognizers currently in training. Allows you to filter the list of recognizers based on
- *       criteria such as status and submission time. This call returns up to 500 entity recognizers in
- *       the list, with a default number of 100 recognizers in the list.</p>
- *          <p>The results of this list are not in any particular order. Please get the list and sort
- *       locally if needed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, ListEntityRecognizersCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListEntityRecognizersCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListEntityRecognizersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEntityRecognizersCommandInput} for command's `input` shape.
- * @see {@link ListEntityRecognizersCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListEntityRecognizersCommand extends $Command<ListEntityRecognizersCommandInput, ListEntityRecognizersCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListEntityRecognizersCommandInput;
     constructor(input: ListEntityRecognizersCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEntityRecognizersCommandInput, ListEntityRecognizersCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListEventsDetectionJobsCommandInput extends ListEventsDetection
 }
 export interface ListEventsDetectionJobsCommandOutput extends ListEventsDetectionJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of the events detection 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, ListEventsDetectionJobsCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListEventsDetectionJobsCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListEventsDetectionJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListEventsDetectionJobsCommandInput} for command's `input` shape.
- * @see {@link ListEventsDetectionJobsCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListEventsDetectionJobsCommand extends $Command<ListEventsDetectionJobsCommandInput, ListEventsDetectionJobsCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListEventsDetectionJobsCommandInput;
     constructor(input: ListEventsDetectionJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEventsDetectionJobsCommandInput, ListEventsDetectionJobsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListKeyPhrasesDetectionJobsCommandInput extends ListKeyPhrasesD
 }
 export interface ListKeyPhrasesDetectionJobsCommandOutput extends ListKeyPhrasesDetectionJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Get a list of key phrase detection 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, ListKeyPhrasesDetectionJobsCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListKeyPhrasesDetectionJobsCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListKeyPhrasesDetectionJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListKeyPhrasesDetectionJobsCommandInput} for command's `input` shape.
- * @see {@link ListKeyPhrasesDetectionJobsCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListKeyPhrasesDetectionJobsCommand extends $Command<ListKeyPhrasesDetectionJobsCommandInput, ListKeyPhrasesDetectionJobsCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListKeyPhrasesDetectionJobsCommandInput;
     constructor(input: ListKeyPhrasesDetectionJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListKeyPhrasesDetectionJobsCommandInput, ListKeyPhrasesDetectionJobsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListPiiEntitiesDetectionJobsCommandInput extends ListPiiEntitie
 }
 export interface ListPiiEntitiesDetectionJobsCommandOutput extends ListPiiEntitiesDetectionJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of the PII entity detection 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, ListPiiEntitiesDetectionJobsCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListPiiEntitiesDetectionJobsCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListPiiEntitiesDetectionJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListPiiEntitiesDetectionJobsCommandInput} for command's `input` shape.
- * @see {@link ListPiiEntitiesDetectionJobsCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListPiiEntitiesDetectionJobsCommand extends $Command<ListPiiEntitiesDetectionJobsCommandInput, ListPiiEntitiesDetectionJobsCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListPiiEntitiesDetectionJobsCommandInput;
     constructor(input: ListPiiEntitiesDetectionJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPiiEntitiesDetectionJobsCommandInput, ListPiiEntitiesDetectionJobsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListSentimentDetectionJobsCommandInput extends ListSentimentDet
 }
 export interface ListSentimentDetectionJobsCommandOutput extends ListSentimentDetectionJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of sentiment detection 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, ListSentimentDetectionJobsCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListSentimentDetectionJobsCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListSentimentDetectionJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSentimentDetectionJobsCommandInput} for command's `input` shape.
- * @see {@link ListSentimentDetectionJobsCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListSentimentDetectionJobsCommand extends $Command<ListSentimentDetectionJobsCommandInput, ListSentimentDetectionJobsCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListSentimentDetectionJobsCommandInput;
     constructor(input: ListSentimentDetectionJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSentimentDetectionJobsCommandInput, ListSentimentDetectionJobsCommandOutput>;
     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>Lists all tags associated with a given Amazon Comprehend resource. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, ListTagsForResourceCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListTagsForResourceCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(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 ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListTopicsDetectionJobsCommandInput extends ListTopicsDetection
 }
 export interface ListTopicsDetectionJobsCommandOutput extends ListTopicsDetectionJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of the topic detection 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, ListTopicsDetectionJobsCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ListTopicsDetectionJobsCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ListTopicsDetectionJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTopicsDetectionJobsCommandInput} for command's `input` shape.
- * @see {@link ListTopicsDetectionJobsCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTopicsDetectionJobsCommand extends $Command<ListTopicsDetectionJobsCommandInput, ListTopicsDetectionJobsCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ListTopicsDetectionJobsCommandInput;
     constructor(input: ListTopicsDetectionJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTopicsDetectionJobsCommandInput, ListTopicsDetectionJobsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface StartDocumentClassificationJobCommandInput extends StartDocumen
 }
 export interface StartDocumentClassificationJobCommandOutput extends StartDocumentClassificationJobResponse, __MetadataBearer {
 }
-/**
- * <p>Starts an asynchronous document classification job. Use the  operation to track the progress of the
- *       job.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, StartDocumentClassificationJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, StartDocumentClassificationJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new StartDocumentClassificationJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartDocumentClassificationJobCommandInput} for command's `input` shape.
- * @see {@link StartDocumentClassificationJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartDocumentClassificationJobCommand extends $Command<StartDocumentClassificationJobCommandInput, StartDocumentClassificationJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: StartDocumentClassificationJobCommandInput;
     constructor(input: StartDocumentClassificationJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartDocumentClassificationJobCommandInput, StartDocumentClassificationJobCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,33 +6,11 @@ export interface StartEntitiesDetectionJobCommandInput extends StartEntitiesDete
 }
 export interface StartEntitiesDetectionJobCommandOutput extends StartEntitiesDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Starts an asynchronous entity detection job for a collection of documents. Use the  operation to track the status of a job.</p>
- *          <p>This API can be used for either standard entity detection or custom entity recognition. In
- *       order to be used for custom entity recognition, the optional <code>EntityRecognizerArn</code>
- *       must be used in order to provide access to the recognizer being used to detect the custom
- *       entity.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, StartEntitiesDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, StartEntitiesDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new StartEntitiesDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartEntitiesDetectionJobCommandInput} for command's `input` shape.
- * @see {@link StartEntitiesDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartEntitiesDetectionJobCommand extends $Command<StartEntitiesDetectionJobCommandInput, StartEntitiesDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: StartEntitiesDetectionJobCommandInput;
     constructor(input: StartEntitiesDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartEntitiesDetectionJobCommandInput, StartEntitiesDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface StartKeyPhrasesDetectionJobCommandInput extends StartKeyPhrases
 }
 export interface StartKeyPhrasesDetectionJobCommandOutput extends StartKeyPhrasesDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Starts an asynchronous key phrase detection job for a collection of documents. Use the
- *          operation to track the status of a
- *       job.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, StartKeyPhrasesDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, StartKeyPhrasesDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new StartKeyPhrasesDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartKeyPhrasesDetectionJobCommandInput} for command's `input` shape.
- * @see {@link StartKeyPhrasesDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartKeyPhrasesDetectionJobCommand extends $Command<StartKeyPhrasesDetectionJobCommandInput, StartKeyPhrasesDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: StartKeyPhrasesDetectionJobCommandInput;
     constructor(input: StartKeyPhrasesDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartKeyPhrasesDetectionJobCommandInput, StartKeyPhrasesDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface StartSentimentDetectionJobCommandInput extends StartSentimentDe
 }
 export interface StartSentimentDetectionJobCommandOutput extends StartSentimentDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Starts an asynchronous sentiment detection job for a collection of documents. use the
- *          operation to track the status of a
- *       job.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, StartSentimentDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, StartSentimentDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new StartSentimentDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartSentimentDetectionJobCommandInput} for command's `input` shape.
- * @see {@link StartSentimentDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartSentimentDetectionJobCommand extends $Command<StartSentimentDetectionJobCommandInput, StartSentimentDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: StartSentimentDetectionJobCommandInput;
     constructor(input: StartSentimentDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartSentimentDetectionJobCommandInput, StartSentimentDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

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