@aws-sdk/client-comprehend 3.35.0 → 3.38.0

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

@@ -6,38 +6,11 @@ export interface StopDominantLanguageDetectionJobCommandInput extends StopDomina
 }
 export interface StopDominantLanguageDetectionJobCommandOutput extends StopDominantLanguageDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Stops a dominant language detection job in progress.</p>
- *          <p>If the job state is <code>IN_PROGRESS</code> the job is marked for termination and put
- *       into the <code>STOP_REQUESTED</code> state. If the job completes before it can be stopped, it
- *       is put into the <code>COMPLETED</code> state; otherwise the job is stopped and put into the
- *         <code>STOPPED</code> state.</p>
- *          <p>If the job is in the <code>COMPLETED</code> or <code>FAILED</code> state when you call the
- *         <code>StopDominantLanguageDetectionJob</code> operation, the operation returns a 400
- *       Internal Request Exception. </p>
- *          <p>When a job is stopped, any documents already processed are written to the output
- *       location.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, StopDominantLanguageDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, StopDominantLanguageDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new StopDominantLanguageDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopDominantLanguageDetectionJobCommandInput} for command's `input` shape.
- * @see {@link StopDominantLanguageDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopDominantLanguageDetectionJobCommand extends $Command<StopDominantLanguageDetectionJobCommandInput, StopDominantLanguageDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: StopDominantLanguageDetectionJobCommandInput;
     constructor(input: StopDominantLanguageDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopDominantLanguageDetectionJobCommandInput, StopDominantLanguageDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface StopEntitiesDetectionJobCommandInput extends StopEntitiesDetect
 }
 export interface StopEntitiesDetectionJobCommandOutput extends StopEntitiesDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Stops an entities detection job in progress.</p>
- *          <p>If the job state is <code>IN_PROGRESS</code> the job is marked for termination and put
- *       into the <code>STOP_REQUESTED</code> state. If the job completes before it can be stopped, it
- *       is put into the <code>COMPLETED</code> state; otherwise the job is stopped and put into the
- *         <code>STOPPED</code> state.</p>
- *          <p>If the job is in the <code>COMPLETED</code> or <code>FAILED</code> state when you call the
- *         <code>StopDominantLanguageDetectionJob</code> operation, the operation returns a 400
- *       Internal Request Exception. </p>
- *          <p>When a job is stopped, any documents already processed are written to the output
- *       location.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, StopEntitiesDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, StopEntitiesDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new StopEntitiesDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopEntitiesDetectionJobCommandInput} for command's `input` shape.
- * @see {@link StopEntitiesDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopEntitiesDetectionJobCommand extends $Command<StopEntitiesDetectionJobCommandInput, StopEntitiesDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: StopEntitiesDetectionJobCommandInput;
     constructor(input: StopEntitiesDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopEntitiesDetectionJobCommandInput, StopEntitiesDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,38 +6,11 @@ export interface StopKeyPhrasesDetectionJobCommandInput extends StopKeyPhrasesDe
 }
 export interface StopKeyPhrasesDetectionJobCommandOutput extends StopKeyPhrasesDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Stops a key phrases detection job in progress.</p>
- *          <p>If the job state is <code>IN_PROGRESS</code> the job is marked for termination and put
- *       into the <code>STOP_REQUESTED</code> state. If the job completes before it can be stopped, it
- *       is put into the <code>COMPLETED</code> state; otherwise the job is stopped and put into the
- *         <code>STOPPED</code> state.</p>
- *          <p>If the job is in the <code>COMPLETED</code> or <code>FAILED</code> state when you call the
- *         <code>StopDominantLanguageDetectionJob</code> operation, the operation returns a 400
- *       Internal Request Exception. </p>
- *          <p>When a job is stopped, any documents already processed are written to the output
- *       location.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, StopKeyPhrasesDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, StopKeyPhrasesDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new StopKeyPhrasesDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopKeyPhrasesDetectionJobCommandInput} for command's `input` shape.
- * @see {@link StopKeyPhrasesDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopKeyPhrasesDetectionJobCommand extends $Command<StopKeyPhrasesDetectionJobCommandInput, StopKeyPhrasesDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: StopKeyPhrasesDetectionJobCommandInput;
     constructor(input: StopKeyPhrasesDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopKeyPhrasesDetectionJobCommandInput, StopKeyPhrasesDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,38 +6,11 @@ export interface StopSentimentDetectionJobCommandInput extends StopSentimentDete
 }
 export interface StopSentimentDetectionJobCommandOutput extends StopSentimentDetectionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Stops a sentiment detection job in progress.</p>
- *          <p>If the job state is <code>IN_PROGRESS</code> the job is marked for termination and put
- *       into the <code>STOP_REQUESTED</code> state. If the job completes before it can be stopped, it
- *       is put into the <code>COMPLETED</code> state; otherwise the job is be stopped and put into the
- *         <code>STOPPED</code> state.</p>
- *          <p>If the job is in the <code>COMPLETED</code> or <code>FAILED</code> state when you call the
- *         <code>StopDominantLanguageDetectionJob</code> operation, the operation returns a 400
- *       Internal Request Exception. </p>
- *          <p>When a job is stopped, any documents already processed are written to the output
- *       location.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, StopSentimentDetectionJobCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, StopSentimentDetectionJobCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new StopSentimentDetectionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopSentimentDetectionJobCommandInput} for command's `input` shape.
- * @see {@link StopSentimentDetectionJobCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopSentimentDetectionJobCommand extends $Command<StopSentimentDetectionJobCommandInput, StopSentimentDetectionJobCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: StopSentimentDetectionJobCommandInput;
     constructor(input: StopSentimentDetectionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopSentimentDetectionJobCommandInput, StopSentimentDetectionJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface StopTrainingDocumentClassifierCommandInput extends StopTraining
 }
 export interface StopTrainingDocumentClassifierCommandOutput extends StopTrainingDocumentClassifierResponse, __MetadataBearer {
 }
-/**
- * <p>Stops a document classifier training job while in progress.</p>
- *          <p>If the training job state is <code>TRAINING</code>, the job is marked for termination and
- *       put into the <code>STOP_REQUESTED</code> state. If the training job completes before it can be
- *       stopped, it is put into the <code>TRAINED</code>; otherwise the training job is stopped and
- *       put into the <code>STOPPED</code> state and the service sends back an HTTP 200 response with
- *       an empty HTTP body. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, StopTrainingDocumentClassifierCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, StopTrainingDocumentClassifierCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new StopTrainingDocumentClassifierCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopTrainingDocumentClassifierCommandInput} for command's `input` shape.
- * @see {@link StopTrainingDocumentClassifierCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopTrainingDocumentClassifierCommand extends $Command<StopTrainingDocumentClassifierCommandInput, StopTrainingDocumentClassifierCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: StopTrainingDocumentClassifierCommandInput;
     constructor(input: StopTrainingDocumentClassifierCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopTrainingDocumentClassifierCommandInput, StopTrainingDocumentClassifierCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface StopTrainingEntityRecognizerCommandInput extends StopTrainingEn
 }
 export interface StopTrainingEntityRecognizerCommandOutput extends StopTrainingEntityRecognizerResponse, __MetadataBearer {
 }
-/**
- * <p>Stops an entity recognizer training job while in progress.</p>
- *          <p>If the training job state is <code>TRAINING</code>, the job is marked for termination and
- *       put into the <code>STOP_REQUESTED</code> state. If the training job completes before it can be
- *       stopped, it is put into the <code>TRAINED</code>; otherwise the training job is stopped and
- *       putted into the <code>STOPPED</code> state and the service sends back an HTTP 200 response
- *       with an empty HTTP body.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, StopTrainingEntityRecognizerCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, StopTrainingEntityRecognizerCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new StopTrainingEntityRecognizerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopTrainingEntityRecognizerCommandInput} for command's `input` shape.
- * @see {@link StopTrainingEntityRecognizerCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StopTrainingEntityRecognizerCommand extends $Command<StopTrainingEntityRecognizerCommandInput, StopTrainingEntityRecognizerCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: StopTrainingEntityRecognizerCommandInput;
     constructor(input: StopTrainingEntityRecognizerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopTrainingEntityRecognizerCommandInput, StopTrainingEntityRecognizerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Associates a specific tag with an Amazon Comprehend resource. A tag is a key-value pair
- *       that adds as a metadata to a resource used by Amazon Comprehend. For example, a tag with
- *       "Sales" as the key might be added to a resource to indicate its use by the sales department.
- *     </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, TagResourceCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, TagResourceCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -0,0 +1,63 @@
+export * from "./BatchDetectDominantLanguageCommand";
+export * from "./BatchDetectEntitiesCommand";
+export * from "./BatchDetectKeyPhrasesCommand";
+export * from "./BatchDetectSentimentCommand";
+export * from "./BatchDetectSyntaxCommand";
+export * from "./ClassifyDocumentCommand";
+export * from "./ContainsPiiEntitiesCommand";
+export * from "./CreateDocumentClassifierCommand";
+export * from "./CreateEndpointCommand";
+export * from "./CreateEntityRecognizerCommand";
+export * from "./DeleteDocumentClassifierCommand";
+export * from "./DeleteEndpointCommand";
+export * from "./DeleteEntityRecognizerCommand";
+export * from "./DescribeDocumentClassificationJobCommand";
+export * from "./DescribeDocumentClassifierCommand";
+export * from "./DescribeDominantLanguageDetectionJobCommand";
+export * from "./DescribeEndpointCommand";
+export * from "./DescribeEntitiesDetectionJobCommand";
+export * from "./DescribeEntityRecognizerCommand";
+export * from "./DescribeEventsDetectionJobCommand";
+export * from "./DescribeKeyPhrasesDetectionJobCommand";
+export * from "./DescribePiiEntitiesDetectionJobCommand";
+export * from "./DescribeSentimentDetectionJobCommand";
+export * from "./DescribeTopicsDetectionJobCommand";
+export * from "./DetectDominantLanguageCommand";
+export * from "./DetectEntitiesCommand";
+export * from "./DetectKeyPhrasesCommand";
+export * from "./DetectPiiEntitiesCommand";
+export * from "./DetectSentimentCommand";
+export * from "./DetectSyntaxCommand";
+export * from "./ListDocumentClassificationJobsCommand";
+export * from "./ListDocumentClassifierSummariesCommand";
+export * from "./ListDocumentClassifiersCommand";
+export * from "./ListDominantLanguageDetectionJobsCommand";
+export * from "./ListEndpointsCommand";
+export * from "./ListEntitiesDetectionJobsCommand";
+export * from "./ListEntityRecognizerSummariesCommand";
+export * from "./ListEntityRecognizersCommand";
+export * from "./ListEventsDetectionJobsCommand";
+export * from "./ListKeyPhrasesDetectionJobsCommand";
+export * from "./ListPiiEntitiesDetectionJobsCommand";
+export * from "./ListSentimentDetectionJobsCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./ListTopicsDetectionJobsCommand";
+export * from "./StartDocumentClassificationJobCommand";
+export * from "./StartDominantLanguageDetectionJobCommand";
+export * from "./StartEntitiesDetectionJobCommand";
+export * from "./StartEventsDetectionJobCommand";
+export * from "./StartKeyPhrasesDetectionJobCommand";
+export * from "./StartPiiEntitiesDetectionJobCommand";
+export * from "./StartSentimentDetectionJobCommand";
+export * from "./StartTopicsDetectionJobCommand";
+export * from "./StopDominantLanguageDetectionJobCommand";
+export * from "./StopEntitiesDetectionJobCommand";
+export * from "./StopEventsDetectionJobCommand";
+export * from "./StopKeyPhrasesDetectionJobCommand";
+export * from "./StopPiiEntitiesDetectionJobCommand";
+export * from "./StopSentimentDetectionJobCommand";
+export * from "./StopTrainingDocumentClassifierCommand";
+export * from "./StopTrainingEntityRecognizerCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateEndpointCommand";

package/dist-types/ts3.4/index.d.ts

@@ -1,78 +1,5 @@
-export * from "./ComprehendClient";
 export * from "./Comprehend";
-export * from "./commands/BatchDetectDominantLanguageCommand";
-export * from "./commands/BatchDetectEntitiesCommand";
-export * from "./commands/BatchDetectKeyPhrasesCommand";
-export * from "./commands/BatchDetectSentimentCommand";
-export * from "./commands/BatchDetectSyntaxCommand";
-export * from "./commands/ClassifyDocumentCommand";
-export * from "./commands/ContainsPiiEntitiesCommand";
-export * from "./commands/CreateDocumentClassifierCommand";
-export * from "./commands/CreateEndpointCommand";
-export * from "./commands/CreateEntityRecognizerCommand";
-export * from "./commands/DeleteDocumentClassifierCommand";
-export * from "./commands/DeleteEndpointCommand";
-export * from "./commands/DeleteEntityRecognizerCommand";
-export * from "./commands/DescribeDocumentClassificationJobCommand";
-export * from "./commands/DescribeDocumentClassifierCommand";
-export * from "./commands/DescribeDominantLanguageDetectionJobCommand";
-export * from "./commands/DescribeEndpointCommand";
-export * from "./commands/DescribeEntitiesDetectionJobCommand";
-export * from "./commands/DescribeEntityRecognizerCommand";
-export * from "./commands/DescribeEventsDetectionJobCommand";
-export * from "./commands/DescribeKeyPhrasesDetectionJobCommand";
-export * from "./commands/DescribePiiEntitiesDetectionJobCommand";
-export * from "./commands/DescribeSentimentDetectionJobCommand";
-export * from "./commands/DescribeTopicsDetectionJobCommand";
-export * from "./commands/DetectDominantLanguageCommand";
-export * from "./commands/DetectEntitiesCommand";
-export * from "./commands/DetectKeyPhrasesCommand";
-export * from "./commands/DetectPiiEntitiesCommand";
-export * from "./commands/DetectSentimentCommand";
-export * from "./commands/DetectSyntaxCommand";
-export * from "./commands/ListDocumentClassificationJobsCommand";
-export * from "./pagination/ListDocumentClassificationJobsPaginator";
-export * from "./commands/ListDocumentClassifiersCommand";
-export * from "./pagination/ListDocumentClassifiersPaginator";
-export * from "./commands/ListDocumentClassifierSummariesCommand";
-export * from "./pagination/ListDocumentClassifierSummariesPaginator";
-export * from "./commands/ListDominantLanguageDetectionJobsCommand";
-export * from "./pagination/ListDominantLanguageDetectionJobsPaginator";
-export * from "./commands/ListEndpointsCommand";
-export * from "./commands/ListEntitiesDetectionJobsCommand";
-export * from "./pagination/ListEntitiesDetectionJobsPaginator";
-export * from "./commands/ListEntityRecognizersCommand";
-export * from "./pagination/ListEntityRecognizersPaginator";
-export * from "./commands/ListEntityRecognizerSummariesCommand";
-export * from "./pagination/ListEntityRecognizerSummariesPaginator";
-export * from "./commands/ListEventsDetectionJobsCommand";
-export * from "./pagination/ListEventsDetectionJobsPaginator";
-export * from "./commands/ListKeyPhrasesDetectionJobsCommand";
-export * from "./pagination/ListKeyPhrasesDetectionJobsPaginator";
-export * from "./commands/ListPiiEntitiesDetectionJobsCommand";
-export * from "./commands/ListSentimentDetectionJobsCommand";
-export * from "./pagination/ListSentimentDetectionJobsPaginator";
-export * from "./commands/ListTagsForResourceCommand";
-export * from "./commands/ListTopicsDetectionJobsCommand";
-export * from "./pagination/ListTopicsDetectionJobsPaginator";
-export * from "./commands/StartDocumentClassificationJobCommand";
-export * from "./commands/StartDominantLanguageDetectionJobCommand";
-export * from "./commands/StartEntitiesDetectionJobCommand";
-export * from "./commands/StartEventsDetectionJobCommand";
-export * from "./commands/StartKeyPhrasesDetectionJobCommand";
-export * from "./commands/StartPiiEntitiesDetectionJobCommand";
-export * from "./commands/StartSentimentDetectionJobCommand";
-export * from "./commands/StartTopicsDetectionJobCommand";
-export * from "./commands/StopDominantLanguageDetectionJobCommand";
-export * from "./commands/StopEntitiesDetectionJobCommand";
-export * from "./commands/StopEventsDetectionJobCommand";
-export * from "./commands/StopKeyPhrasesDetectionJobCommand";
-export * from "./commands/StopPiiEntitiesDetectionJobCommand";
-export * from "./commands/StopSentimentDetectionJobCommand";
-export * from "./commands/StopTrainingDocumentClassifierCommand";
-export * from "./commands/StopTrainingEntityRecognizerCommand";
-export * from "./commands/TagResourceCommand";
-export * from "./commands/UntagResourceCommand";
-export * from "./commands/UpdateEndpointCommand";
-export * from "./pagination/Interfaces";
-export * from "./models/index";
+export * from "./ComprehendClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";