@aws-sdk/client-comprehend 3.34.0 → 3.37.0

package/dist/types/commands/DeleteEndpointCommand.d.ts

@@ -1,36 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { DeleteEndpointRequest, DeleteEndpointResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-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/commands/DeleteEntityRecognizerCommand.d.ts

@@ -1,41 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { DeleteEntityRecognizerRequest, DeleteEntityRecognizerResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteEntityRecognizerCommandInput extends DeleteEntityRecognizerRequest {
-}
-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/commands/DescribeDocumentClassificationJobCommand.d.ts

@@ -1,36 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { DescribeDocumentClassificationJobRequest, DescribeDocumentClassificationJobResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDocumentClassificationJobCommandInput extends DescribeDocumentClassificationJobRequest {
-}
-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;
-}

package/dist/types/commands/DescribeDocumentClassifierCommand.d.ts

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

package/dist/types/commands/DescribeDominantLanguageDetectionJobCommand.d.ts

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

package/dist/types/commands/DescribeEndpointCommand.d.ts

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

package/dist/types/commands/DescribeEntitiesDetectionJobCommand.d.ts

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

package/dist/types/commands/DescribeEntityRecognizerCommand.d.ts

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

package/dist/types/commands/DescribeEventsDetectionJobCommand.d.ts

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

package/dist/types/commands/DescribeKeyPhrasesDetectionJobCommand.d.ts

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

package/dist/types/commands/DescribePiiEntitiesDetectionJobCommand.d.ts

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

package/dist/types/commands/DescribeSentimentDetectionJobCommand.d.ts

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

package/dist/types/commands/DescribeTopicsDetectionJobCommand.d.ts

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

package/dist/types/commands/DetectDominantLanguageCommand.d.ts

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

package/dist/types/commands/DetectEntitiesCommand.d.ts

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

package/dist/types/commands/DetectKeyPhrasesCommand.d.ts

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

package/dist/types/commands/DetectPiiEntitiesCommand.d.ts

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