@aws-sdk/client-comprehend 3.34.0 → 3.37.0

package/dist-es/commands/StartEventsDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartEventsDetectionJobRequest, StartEventsDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StartEventsDetectionJobCommand, serializeAws_json1_1StartEventsDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StartEventsDetectionJobCommand = (function (_super) {
+    __extends(StartEventsDetectionJobCommand, _super);
+    function StartEventsDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StartEventsDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StartEventsDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StartEventsDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StartEventsDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartEventsDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StartEventsDetectionJobCommand(input, context);
+    };
+    StartEventsDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StartEventsDetectionJobCommand(output, context);
+    };
+    return StartEventsDetectionJobCommand;
+}($Command));
+export { StartEventsDetectionJobCommand };

package/dist-es/commands/StartKeyPhrasesDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartKeyPhrasesDetectionJobRequest, StartKeyPhrasesDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StartKeyPhrasesDetectionJobCommand, serializeAws_json1_1StartKeyPhrasesDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StartKeyPhrasesDetectionJobCommand = (function (_super) {
+    __extends(StartKeyPhrasesDetectionJobCommand, _super);
+    function StartKeyPhrasesDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StartKeyPhrasesDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StartKeyPhrasesDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StartKeyPhrasesDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StartKeyPhrasesDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartKeyPhrasesDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StartKeyPhrasesDetectionJobCommand(input, context);
+    };
+    StartKeyPhrasesDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StartKeyPhrasesDetectionJobCommand(output, context);
+    };
+    return StartKeyPhrasesDetectionJobCommand;
+}($Command));
+export { StartKeyPhrasesDetectionJobCommand };

package/dist-es/commands/StartPiiEntitiesDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartPiiEntitiesDetectionJobRequest, StartPiiEntitiesDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StartPiiEntitiesDetectionJobCommand, serializeAws_json1_1StartPiiEntitiesDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StartPiiEntitiesDetectionJobCommand = (function (_super) {
+    __extends(StartPiiEntitiesDetectionJobCommand, _super);
+    function StartPiiEntitiesDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StartPiiEntitiesDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StartPiiEntitiesDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StartPiiEntitiesDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StartPiiEntitiesDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartPiiEntitiesDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StartPiiEntitiesDetectionJobCommand(input, context);
+    };
+    StartPiiEntitiesDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StartPiiEntitiesDetectionJobCommand(output, context);
+    };
+    return StartPiiEntitiesDetectionJobCommand;
+}($Command));
+export { StartPiiEntitiesDetectionJobCommand };

package/dist-es/commands/StartSentimentDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartSentimentDetectionJobRequest, StartSentimentDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StartSentimentDetectionJobCommand, serializeAws_json1_1StartSentimentDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StartSentimentDetectionJobCommand = (function (_super) {
+    __extends(StartSentimentDetectionJobCommand, _super);
+    function StartSentimentDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StartSentimentDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StartSentimentDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StartSentimentDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StartSentimentDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartSentimentDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StartSentimentDetectionJobCommand(input, context);
+    };
+    StartSentimentDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StartSentimentDetectionJobCommand(output, context);
+    };
+    return StartSentimentDetectionJobCommand;
+}($Command));
+export { StartSentimentDetectionJobCommand };

package/dist-es/commands/StartTopicsDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StartTopicsDetectionJobRequest, StartTopicsDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StartTopicsDetectionJobCommand, serializeAws_json1_1StartTopicsDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StartTopicsDetectionJobCommand = (function (_super) {
+    __extends(StartTopicsDetectionJobCommand, _super);
+    function StartTopicsDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StartTopicsDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StartTopicsDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StartTopicsDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StartTopicsDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartTopicsDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StartTopicsDetectionJobCommand(input, context);
+    };
+    StartTopicsDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StartTopicsDetectionJobCommand(output, context);
+    };
+    return StartTopicsDetectionJobCommand;
+}($Command));
+export { StartTopicsDetectionJobCommand };

package/dist-es/commands/StopDominantLanguageDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StopDominantLanguageDetectionJobRequest, StopDominantLanguageDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StopDominantLanguageDetectionJobCommand, serializeAws_json1_1StopDominantLanguageDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StopDominantLanguageDetectionJobCommand = (function (_super) {
+    __extends(StopDominantLanguageDetectionJobCommand, _super);
+    function StopDominantLanguageDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopDominantLanguageDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StopDominantLanguageDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopDominantLanguageDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StopDominantLanguageDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopDominantLanguageDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StopDominantLanguageDetectionJobCommand(input, context);
+    };
+    StopDominantLanguageDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StopDominantLanguageDetectionJobCommand(output, context);
+    };
+    return StopDominantLanguageDetectionJobCommand;
+}($Command));
+export { StopDominantLanguageDetectionJobCommand };

package/dist-es/commands/StopEntitiesDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StopEntitiesDetectionJobRequest, StopEntitiesDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StopEntitiesDetectionJobCommand, serializeAws_json1_1StopEntitiesDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StopEntitiesDetectionJobCommand = (function (_super) {
+    __extends(StopEntitiesDetectionJobCommand, _super);
+    function StopEntitiesDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopEntitiesDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StopEntitiesDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopEntitiesDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StopEntitiesDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopEntitiesDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StopEntitiesDetectionJobCommand(input, context);
+    };
+    StopEntitiesDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StopEntitiesDetectionJobCommand(output, context);
+    };
+    return StopEntitiesDetectionJobCommand;
+}($Command));
+export { StopEntitiesDetectionJobCommand };

package/dist-es/commands/StopEventsDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StopEventsDetectionJobRequest, StopEventsDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StopEventsDetectionJobCommand, serializeAws_json1_1StopEventsDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StopEventsDetectionJobCommand = (function (_super) {
+    __extends(StopEventsDetectionJobCommand, _super);
+    function StopEventsDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopEventsDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StopEventsDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopEventsDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StopEventsDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopEventsDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StopEventsDetectionJobCommand(input, context);
+    };
+    StopEventsDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StopEventsDetectionJobCommand(output, context);
+    };
+    return StopEventsDetectionJobCommand;
+}($Command));
+export { StopEventsDetectionJobCommand };

package/dist-es/commands/StopKeyPhrasesDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StopKeyPhrasesDetectionJobRequest, StopKeyPhrasesDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StopKeyPhrasesDetectionJobCommand, serializeAws_json1_1StopKeyPhrasesDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StopKeyPhrasesDetectionJobCommand = (function (_super) {
+    __extends(StopKeyPhrasesDetectionJobCommand, _super);
+    function StopKeyPhrasesDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopKeyPhrasesDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StopKeyPhrasesDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopKeyPhrasesDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StopKeyPhrasesDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopKeyPhrasesDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StopKeyPhrasesDetectionJobCommand(input, context);
+    };
+    StopKeyPhrasesDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StopKeyPhrasesDetectionJobCommand(output, context);
+    };
+    return StopKeyPhrasesDetectionJobCommand;
+}($Command));
+export { StopKeyPhrasesDetectionJobCommand };

package/dist-es/commands/StopPiiEntitiesDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StopPiiEntitiesDetectionJobRequest, StopPiiEntitiesDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StopPiiEntitiesDetectionJobCommand, serializeAws_json1_1StopPiiEntitiesDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StopPiiEntitiesDetectionJobCommand = (function (_super) {
+    __extends(StopPiiEntitiesDetectionJobCommand, _super);
+    function StopPiiEntitiesDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopPiiEntitiesDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StopPiiEntitiesDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopPiiEntitiesDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StopPiiEntitiesDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopPiiEntitiesDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StopPiiEntitiesDetectionJobCommand(input, context);
+    };
+    StopPiiEntitiesDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StopPiiEntitiesDetectionJobCommand(output, context);
+    };
+    return StopPiiEntitiesDetectionJobCommand;
+}($Command));
+export { StopPiiEntitiesDetectionJobCommand };

package/dist-es/commands/StopSentimentDetectionJobCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StopSentimentDetectionJobRequest, StopSentimentDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1StopSentimentDetectionJobCommand, serializeAws_json1_1StopSentimentDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var StopSentimentDetectionJobCommand = (function (_super) {
+    __extends(StopSentimentDetectionJobCommand, _super);
+    function StopSentimentDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopSentimentDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StopSentimentDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopSentimentDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StopSentimentDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopSentimentDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StopSentimentDetectionJobCommand(input, context);
+    };
+    StopSentimentDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StopSentimentDetectionJobCommand(output, context);
+    };
+    return StopSentimentDetectionJobCommand;
+}($Command));
+export { StopSentimentDetectionJobCommand };

package/dist-es/commands/StopTrainingDocumentClassifierCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StopTrainingDocumentClassifierRequest, StopTrainingDocumentClassifierResponse } from "../models/models_0";
+import { deserializeAws_json1_1StopTrainingDocumentClassifierCommand, serializeAws_json1_1StopTrainingDocumentClassifierCommand, } from "../protocols/Aws_json1_1";
+var StopTrainingDocumentClassifierCommand = (function (_super) {
+    __extends(StopTrainingDocumentClassifierCommand, _super);
+    function StopTrainingDocumentClassifierCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopTrainingDocumentClassifierCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StopTrainingDocumentClassifierCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopTrainingDocumentClassifierRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StopTrainingDocumentClassifierResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopTrainingDocumentClassifierCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StopTrainingDocumentClassifierCommand(input, context);
+    };
+    StopTrainingDocumentClassifierCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StopTrainingDocumentClassifierCommand(output, context);
+    };
+    return StopTrainingDocumentClassifierCommand;
+}($Command));
+export { StopTrainingDocumentClassifierCommand };

package/dist-es/commands/StopTrainingEntityRecognizerCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { StopTrainingEntityRecognizerRequest, StopTrainingEntityRecognizerResponse } from "../models/models_0";
+import { deserializeAws_json1_1StopTrainingEntityRecognizerCommand, serializeAws_json1_1StopTrainingEntityRecognizerCommand, } from "../protocols/Aws_json1_1";
+var StopTrainingEntityRecognizerCommand = (function (_super) {
+    __extends(StopTrainingEntityRecognizerCommand, _super);
+    function StopTrainingEntityRecognizerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StopTrainingEntityRecognizerCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "StopTrainingEntityRecognizerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StopTrainingEntityRecognizerRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: StopTrainingEntityRecognizerResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StopTrainingEntityRecognizerCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1StopTrainingEntityRecognizerCommand(input, context);
+    };
+    StopTrainingEntityRecognizerCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1StopTrainingEntityRecognizerCommand(output, context);
+    };
+    return StopTrainingEntityRecognizerCommand;
+}($Command));
+export { StopTrainingEntityRecognizerCommand };

package/dist-es/commands/TagResourceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+import { deserializeAws_json1_1TagResourceCommand, serializeAws_json1_1TagResourceCommand, } from "../protocols/Aws_json1_1";
+var TagResourceCommand = (function (_super) {
+    __extends(TagResourceCommand, _super);
+    function TagResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    TagResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "TagResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: TagResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: TagResourceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    TagResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1TagResourceCommand(input, context);
+    };
+    TagResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1TagResourceCommand(output, context);
+    };
+    return TagResourceCommand;
+}($Command));
+export { TagResourceCommand };

package/dist-es/commands/UntagResourceCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UntagResourceRequest, UntagResourceResponse } from "../models/models_0";
+import { deserializeAws_json1_1UntagResourceCommand, serializeAws_json1_1UntagResourceCommand, } from "../protocols/Aws_json1_1";
+var UntagResourceCommand = (function (_super) {
+    __extends(UntagResourceCommand, _super);
+    function UntagResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UntagResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "UntagResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UntagResourceRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UntagResourceResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UntagResourceCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1UntagResourceCommand(input, context);
+    };
+    UntagResourceCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1UntagResourceCommand(output, context);
+    };
+    return UntagResourceCommand;
+}($Command));
+export { UntagResourceCommand };

package/dist-es/commands/UpdateEndpointCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateEndpointRequest, UpdateEndpointResponse } from "../models/models_0";
+import { deserializeAws_json1_1UpdateEndpointCommand, serializeAws_json1_1UpdateEndpointCommand, } from "../protocols/Aws_json1_1";
+var UpdateEndpointCommand = (function (_super) {
+    __extends(UpdateEndpointCommand, _super);
+    function UpdateEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateEndpointCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "UpdateEndpointCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateEndpointRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateEndpointResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateEndpointCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1UpdateEndpointCommand(input, context);
+    };
+    UpdateEndpointCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1UpdateEndpointCommand(output, context);
+    };
+    return UpdateEndpointCommand;
+}($Command));
+export { UpdateEndpointCommand };