@aws-sdk/client-comprehend 3.35.0 → 3.38.0

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

@@ -72,127 +72,59 @@ import { UpdateEndpointCommandInput, UpdateEndpointCommandOutput } from "./comma
 export declare type ServiceInputTypes = BatchDetectDominantLanguageCommandInput | BatchDetectEntitiesCommandInput | BatchDetectKeyPhrasesCommandInput | BatchDetectSentimentCommandInput | BatchDetectSyntaxCommandInput | ClassifyDocumentCommandInput | ContainsPiiEntitiesCommandInput | CreateDocumentClassifierCommandInput | CreateEndpointCommandInput | CreateEntityRecognizerCommandInput | DeleteDocumentClassifierCommandInput | DeleteEndpointCommandInput | DeleteEntityRecognizerCommandInput | DescribeDocumentClassificationJobCommandInput | DescribeDocumentClassifierCommandInput | DescribeDominantLanguageDetectionJobCommandInput | DescribeEndpointCommandInput | DescribeEntitiesDetectionJobCommandInput | DescribeEntityRecognizerCommandInput | DescribeEventsDetectionJobCommandInput | DescribeKeyPhrasesDetectionJobCommandInput | DescribePiiEntitiesDetectionJobCommandInput | DescribeSentimentDetectionJobCommandInput | DescribeTopicsDetectionJobCommandInput | DetectDominantLanguageCommandInput | DetectEntitiesCommandInput | DetectKeyPhrasesCommandInput | DetectPiiEntitiesCommandInput | DetectSentimentCommandInput | DetectSyntaxCommandInput | ListDocumentClassificationJobsCommandInput | ListDocumentClassifierSummariesCommandInput | ListDocumentClassifiersCommandInput | ListDominantLanguageDetectionJobsCommandInput | ListEndpointsCommandInput | ListEntitiesDetectionJobsCommandInput | ListEntityRecognizerSummariesCommandInput | ListEntityRecognizersCommandInput | ListEventsDetectionJobsCommandInput | ListKeyPhrasesDetectionJobsCommandInput | ListPiiEntitiesDetectionJobsCommandInput | ListSentimentDetectionJobsCommandInput | ListTagsForResourceCommandInput | ListTopicsDetectionJobsCommandInput | StartDocumentClassificationJobCommandInput | StartDominantLanguageDetectionJobCommandInput | StartEntitiesDetectionJobCommandInput | StartEventsDetectionJobCommandInput | StartKeyPhrasesDetectionJobCommandInput | StartPiiEntitiesDetectionJobCommandInput | StartSentimentDetectionJobCommandInput | StartTopicsDetectionJobCommandInput | StopDominantLanguageDetectionJobCommandInput | StopEntitiesDetectionJobCommandInput | StopEventsDetectionJobCommandInput | StopKeyPhrasesDetectionJobCommandInput | StopPiiEntitiesDetectionJobCommandInput | StopSentimentDetectionJobCommandInput | StopTrainingDocumentClassifierCommandInput | StopTrainingEntityRecognizerCommandInput | TagResourceCommandInput | UntagResourceCommandInput | UpdateEndpointCommandInput;
 export declare type ServiceOutputTypes = BatchDetectDominantLanguageCommandOutput | BatchDetectEntitiesCommandOutput | BatchDetectKeyPhrasesCommandOutput | BatchDetectSentimentCommandOutput | BatchDetectSyntaxCommandOutput | ClassifyDocumentCommandOutput | ContainsPiiEntitiesCommandOutput | CreateDocumentClassifierCommandOutput | CreateEndpointCommandOutput | CreateEntityRecognizerCommandOutput | DeleteDocumentClassifierCommandOutput | DeleteEndpointCommandOutput | DeleteEntityRecognizerCommandOutput | DescribeDocumentClassificationJobCommandOutput | DescribeDocumentClassifierCommandOutput | DescribeDominantLanguageDetectionJobCommandOutput | DescribeEndpointCommandOutput | DescribeEntitiesDetectionJobCommandOutput | DescribeEntityRecognizerCommandOutput | DescribeEventsDetectionJobCommandOutput | DescribeKeyPhrasesDetectionJobCommandOutput | DescribePiiEntitiesDetectionJobCommandOutput | DescribeSentimentDetectionJobCommandOutput | DescribeTopicsDetectionJobCommandOutput | DetectDominantLanguageCommandOutput | DetectEntitiesCommandOutput | DetectKeyPhrasesCommandOutput | DetectPiiEntitiesCommandOutput | DetectSentimentCommandOutput | DetectSyntaxCommandOutput | ListDocumentClassificationJobsCommandOutput | ListDocumentClassifierSummariesCommandOutput | ListDocumentClassifiersCommandOutput | ListDominantLanguageDetectionJobsCommandOutput | ListEndpointsCommandOutput | ListEntitiesDetectionJobsCommandOutput | ListEntityRecognizerSummariesCommandOutput | ListEntityRecognizersCommandOutput | ListEventsDetectionJobsCommandOutput | ListKeyPhrasesDetectionJobsCommandOutput | ListPiiEntitiesDetectionJobsCommandOutput | ListSentimentDetectionJobsCommandOutput | ListTagsForResourceCommandOutput | ListTopicsDetectionJobsCommandOutput | StartDocumentClassificationJobCommandOutput | StartDominantLanguageDetectionJobCommandOutput | StartEntitiesDetectionJobCommandOutput | StartEventsDetectionJobCommandOutput | StartKeyPhrasesDetectionJobCommandOutput | StartPiiEntitiesDetectionJobCommandOutput | StartSentimentDetectionJobCommandOutput | StartTopicsDetectionJobCommandOutput | StopDominantLanguageDetectionJobCommandOutput | StopEntitiesDetectionJobCommandOutput | StopEventsDetectionJobCommandOutput | StopKeyPhrasesDetectionJobCommandOutput | StopPiiEntitiesDetectionJobCommandOutput | StopSentimentDetectionJobCommandOutput | StopTrainingDocumentClassifierCommandOutput | StopTrainingEntityRecognizerCommandOutput | TagResourceCommandOutput | UntagResourceCommandOutput | UpdateEndpointCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type ComprehendClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of ComprehendClient class constructor that set the region, credentials and other options.
- */
+
 export interface ComprehendClientConfig extends ComprehendClientConfigType {
 }
 declare type ComprehendClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of ComprehendClient class. This is resolved and normalized from the {@link ComprehendClientConfig | constructor configuration interface}.
- */
+
 export interface ComprehendClientResolvedConfig extends ComprehendClientResolvedConfigType {
 }
-/**
- * <p>Amazon Comprehend is an AWS service for gaining insight into the content of documents.
- *       Use these actions to determine the topics contained in your documents, the topics they
- *       discuss, the predominant sentiment expressed in them, the predominant language used, and
- *       more.</p>
- */
+
 export declare class ComprehendClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, ComprehendClientResolvedConfig> {
-    /**
-     * The resolved configuration of ComprehendClient class. This is resolved and normalized from the {@link ComprehendClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: ComprehendClientResolvedConfig;
     constructor(configuration: ComprehendClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

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

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

@@ -6,31 +6,11 @@ export interface BatchDetectEntitiesCommandInput extends BatchDetectEntitiesRequ
 }
 export interface BatchDetectEntitiesCommandOutput extends BatchDetectEntitiesResponse, __MetadataBearer {
 }
-/**
- * <p>Inspects the text of a batch of documents 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, BatchDetectEntitiesCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, BatchDetectEntitiesCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new BatchDetectEntitiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link BatchDetectEntitiesCommandInput} for command's `input` shape.
- * @see {@link BatchDetectEntitiesCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class BatchDetectEntitiesCommand extends $Command<BatchDetectEntitiesCommandInput, BatchDetectEntitiesCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: BatchDetectEntitiesCommandInput;
     constructor(input: BatchDetectEntitiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchDetectEntitiesCommandInput, BatchDetectEntitiesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface ClassifyDocumentCommandInput extends ClassifyDocumentRequest {
 }
 export interface ClassifyDocumentCommandOutput extends ClassifyDocumentResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new document classification request to analyze a single document in real-time,
- *       using a previously created and trained custom model and an endpoint.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, ClassifyDocumentCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ClassifyDocumentCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ClassifyDocumentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ClassifyDocumentCommandInput} for command's `input` shape.
- * @see {@link ClassifyDocumentCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ClassifyDocumentCommand extends $Command<ClassifyDocumentCommandInput, ClassifyDocumentCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ClassifyDocumentCommandInput;
     constructor(input: ClassifyDocumentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ClassifyDocumentCommandInput, ClassifyDocumentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ContainsPiiEntitiesCommandInput extends ContainsPiiEntitiesRequ
 }
 export interface ContainsPiiEntitiesCommandOutput extends ContainsPiiEntitiesResponse, __MetadataBearer {
 }
-/**
- * <p>Analyzes input text for the presence of personally identifiable information (PII) and
- *       returns the labels of identified PII entity types such as name, address, bank account number,
- *       or phone number.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, ContainsPiiEntitiesCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, ContainsPiiEntitiesCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new ContainsPiiEntitiesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ContainsPiiEntitiesCommandInput} for command's `input` shape.
- * @see {@link ContainsPiiEntitiesCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ContainsPiiEntitiesCommand extends $Command<ContainsPiiEntitiesCommandInput, ContainsPiiEntitiesCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: ContainsPiiEntitiesCommandInput;
     constructor(input: ContainsPiiEntitiesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ContainsPiiEntitiesCommandInput, ContainsPiiEntitiesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateDocumentClassifierCommandInput extends CreateDocumentClas
 }
 export interface CreateDocumentClassifierCommandOutput extends CreateDocumentClassifierResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new document classifier that you can use to categorize documents. To create a
- *       classifier, you provide a set of training documents that labeled with the categories that you
- *       want to use. After the classifier is trained you can use it to categorize a set of labeled
- *       documents into the categories. For more information, see <a>how-document-classification</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, CreateDocumentClassifierCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, CreateDocumentClassifierCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new CreateDocumentClassifierCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDocumentClassifierCommandInput} for command's `input` shape.
- * @see {@link CreateDocumentClassifierCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDocumentClassifierCommand extends $Command<CreateDocumentClassifierCommandInput, CreateDocumentClassifierCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: CreateDocumentClassifierCommandInput;
     constructor(input: CreateDocumentClassifierCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDocumentClassifierCommandInput, CreateDocumentClassifierCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateEndpointCommandInput extends CreateEndpointRequest {
 }
 export interface CreateEndpointCommandOutput extends CreateEndpointResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a model-specific endpoint for synchronous inference for a previously trained
- *       custom model
- *       </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, CreateEndpointCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, CreateEndpointCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new CreateEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEndpointCommandInput} for command's `input` shape.
- * @see {@link CreateEndpointCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateEndpointCommand extends $Command<CreateEndpointCommandInput, CreateEndpointCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: CreateEndpointCommandInput;
     constructor(input: CreateEndpointCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEndpointCommandInput, CreateEndpointCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateEntityRecognizerCommandInput extends CreateEntityRecogniz
 }
 export interface CreateEntityRecognizerCommandOutput extends CreateEntityRecognizerResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an entity recognizer using submitted files. After your
- *         <code>CreateEntityRecognizer</code> request is submitted, you can check job status using the
- *          API. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, CreateEntityRecognizerCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, CreateEntityRecognizerCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new CreateEntityRecognizerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEntityRecognizerCommandInput} for command's `input` shape.
- * @see {@link CreateEntityRecognizerCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateEntityRecognizerCommand extends $Command<CreateEntityRecognizerCommandInput, CreateEntityRecognizerCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: CreateEntityRecognizerCommandInput;
     constructor(input: CreateEntityRecognizerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEntityRecognizerCommandInput, CreateEntityRecognizerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface DeleteDocumentClassifierCommandInput extends DeleteDocumentClas
 }
 export interface DeleteDocumentClassifierCommandOutput extends DeleteDocumentClassifierResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a previously created document classifier</p>
- *          <p>Only those classifiers that are in terminated states (IN_ERROR, TRAINED) will be deleted.
- *       If an active inference job is using the model, a <code>ResourceInUseException</code> will be
- *       returned.</p>
- *          <p>This is an asynchronous action that puts the classifier into a DELETING state, and it is
- *       then removed by a background job. Once removed, the classifier disappears from your account
- *       and is no longer available for use. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DeleteDocumentClassifierCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DeleteDocumentClassifierCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DeleteDocumentClassifierCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDocumentClassifierCommandInput} for command's `input` shape.
- * @see {@link DeleteDocumentClassifierCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDocumentClassifierCommand extends $Command<DeleteDocumentClassifierCommandInput, DeleteDocumentClassifierCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DeleteDocumentClassifierCommandInput;
     constructor(input: DeleteDocumentClassifierCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDocumentClassifierCommandInput, DeleteDocumentClassifierCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,35 +6,11 @@ export interface DeleteEntityRecognizerCommandInput extends DeleteEntityRecogniz
 }
 export interface DeleteEntityRecognizerCommandOutput extends DeleteEntityRecognizerResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an entity recognizer.</p>
- *          <p>Only those recognizers that are in terminated states (IN_ERROR, TRAINED) will be deleted.
- *       If an active inference job is using the model, a <code>ResourceInUseException</code> will be
- *       returned.</p>
- *          <p>This is an asynchronous action that puts the recognizer into a DELETING state, and it is
- *       then removed by a background job. Once removed, the recognizer disappears from your account
- *       and is no longer available for use. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ComprehendClient, DeleteEntityRecognizerCommand } from "@aws-sdk/client-comprehend"; // ES Modules import
- * // const { ComprehendClient, DeleteEntityRecognizerCommand } = require("@aws-sdk/client-comprehend"); // CommonJS import
- * const client = new ComprehendClient(config);
- * const command = new DeleteEntityRecognizerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEntityRecognizerCommandInput} for command's `input` shape.
- * @see {@link DeleteEntityRecognizerCommandOutput} for command's `response` shape.
- * @see {@link ComprehendClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteEntityRecognizerCommand extends $Command<DeleteEntityRecognizerCommandInput, DeleteEntityRecognizerCommandOutput, ComprehendClientResolvedConfig> {
     readonly input: DeleteEntityRecognizerCommandInput;
     constructor(input: DeleteEntityRecognizerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ComprehendClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEntityRecognizerCommandInput, DeleteEntityRecognizerCommandOutput>;
     private serialize;
     private deserialize;

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

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