@aws-sdk/client-comprehend 3.34.0 → 3.37.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,44 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { StopDominantLanguageDetectionJobRequest, StopDominantLanguageDetectionJobResponse } 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 StopDominantLanguageDetectionJobCommandInput extends StopDominantLanguageDetectionJobRequest {
-}
-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

@@ -1,44 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { StopEntitiesDetectionJobRequest, StopEntitiesDetectionJobResponse } 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 StopEntitiesDetectionJobCommandInput extends StopEntitiesDetectionJobRequest {
-}
-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

@@ -1,35 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { StopEventsDetectionJobRequest, StopEventsDetectionJobResponse } 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 StopEventsDetectionJobCommandInput extends StopEventsDetectionJobRequest {
-}
-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

@@ -1,44 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { StopKeyPhrasesDetectionJobRequest, StopKeyPhrasesDetectionJobResponse } 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 StopKeyPhrasesDetectionJobCommandInput extends StopKeyPhrasesDetectionJobRequest {
-}
-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

@@ -1,35 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { StopPiiEntitiesDetectionJobRequest, StopPiiEntitiesDetectionJobResponse } 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 StopPiiEntitiesDetectionJobCommandInput extends StopPiiEntitiesDetectionJobRequest {
-}
-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

@@ -1,44 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { StopSentimentDetectionJobRequest, StopSentimentDetectionJobResponse } 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 StopSentimentDetectionJobCommandInput extends StopSentimentDetectionJobRequest {
-}
-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

@@ -1,40 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { StopTrainingDocumentClassifierRequest, StopTrainingDocumentClassifierResponse } 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 StopTrainingDocumentClassifierCommandInput extends StopTrainingDocumentClassifierRequest {
-}
-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

@@ -1,40 +0,0 @@
-import { ComprehendClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ComprehendClient";
-import { StopTrainingEntityRecognizerRequest, StopTrainingEntityRecognizerResponse } 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 StopTrainingEntityRecognizerCommandInput extends StopTrainingEntityRecognizerRequest {
-}
-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;
-}