@aws-sdk/client-comprehend 3.34.0 → 3.37.0

package/dist-es/commands/DescribeDominantLanguageDetectionJobCommand.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 { DescribeDominantLanguageDetectionJobRequest, DescribeDominantLanguageDetectionJobResponse, } from "../models/models_0";
+import { deserializeAws_json1_1DescribeDominantLanguageDetectionJobCommand, serializeAws_json1_1DescribeDominantLanguageDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var DescribeDominantLanguageDetectionJobCommand = (function (_super) {
+    __extends(DescribeDominantLanguageDetectionJobCommand, _super);
+    function DescribeDominantLanguageDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeDominantLanguageDetectionJobCommand.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 = "DescribeDominantLanguageDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeDominantLanguageDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeDominantLanguageDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeDominantLanguageDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeDominantLanguageDetectionJobCommand(input, context);
+    };
+    DescribeDominantLanguageDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeDominantLanguageDetectionJobCommand(output, context);
+    };
+    return DescribeDominantLanguageDetectionJobCommand;
+}($Command));
+export { DescribeDominantLanguageDetectionJobCommand };

package/dist-es/commands/DescribeEndpointCommand.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 { DescribeEndpointRequest, DescribeEndpointResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribeEndpointCommand, serializeAws_json1_1DescribeEndpointCommand, } from "../protocols/Aws_json1_1";
+var DescribeEndpointCommand = (function (_super) {
+    __extends(DescribeEndpointCommand, _super);
+    function DescribeEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeEndpointCommand.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 = "DescribeEndpointCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeEndpointRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeEndpointResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeEndpointCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeEndpointCommand(input, context);
+    };
+    DescribeEndpointCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeEndpointCommand(output, context);
+    };
+    return DescribeEndpointCommand;
+}($Command));
+export { DescribeEndpointCommand };

package/dist-es/commands/DescribeEntitiesDetectionJobCommand.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 { DescribeEntitiesDetectionJobRequest, DescribeEntitiesDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribeEntitiesDetectionJobCommand, serializeAws_json1_1DescribeEntitiesDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var DescribeEntitiesDetectionJobCommand = (function (_super) {
+    __extends(DescribeEntitiesDetectionJobCommand, _super);
+    function DescribeEntitiesDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeEntitiesDetectionJobCommand.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 = "DescribeEntitiesDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeEntitiesDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeEntitiesDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeEntitiesDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeEntitiesDetectionJobCommand(input, context);
+    };
+    DescribeEntitiesDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeEntitiesDetectionJobCommand(output, context);
+    };
+    return DescribeEntitiesDetectionJobCommand;
+}($Command));
+export { DescribeEntitiesDetectionJobCommand };

package/dist-es/commands/DescribeEntityRecognizerCommand.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 { DescribeEntityRecognizerRequest, DescribeEntityRecognizerResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribeEntityRecognizerCommand, serializeAws_json1_1DescribeEntityRecognizerCommand, } from "../protocols/Aws_json1_1";
+var DescribeEntityRecognizerCommand = (function (_super) {
+    __extends(DescribeEntityRecognizerCommand, _super);
+    function DescribeEntityRecognizerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeEntityRecognizerCommand.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 = "DescribeEntityRecognizerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeEntityRecognizerRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeEntityRecognizerResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeEntityRecognizerCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeEntityRecognizerCommand(input, context);
+    };
+    DescribeEntityRecognizerCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeEntityRecognizerCommand(output, context);
+    };
+    return DescribeEntityRecognizerCommand;
+}($Command));
+export { DescribeEntityRecognizerCommand };

package/dist-es/commands/DescribeEventsDetectionJobCommand.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 { DescribeEventsDetectionJobRequest, DescribeEventsDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribeEventsDetectionJobCommand, serializeAws_json1_1DescribeEventsDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var DescribeEventsDetectionJobCommand = (function (_super) {
+    __extends(DescribeEventsDetectionJobCommand, _super);
+    function DescribeEventsDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeEventsDetectionJobCommand.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 = "DescribeEventsDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeEventsDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeEventsDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeEventsDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeEventsDetectionJobCommand(input, context);
+    };
+    DescribeEventsDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeEventsDetectionJobCommand(output, context);
+    };
+    return DescribeEventsDetectionJobCommand;
+}($Command));
+export { DescribeEventsDetectionJobCommand };

package/dist-es/commands/DescribeKeyPhrasesDetectionJobCommand.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 { DescribeKeyPhrasesDetectionJobRequest, DescribeKeyPhrasesDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribeKeyPhrasesDetectionJobCommand, serializeAws_json1_1DescribeKeyPhrasesDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var DescribeKeyPhrasesDetectionJobCommand = (function (_super) {
+    __extends(DescribeKeyPhrasesDetectionJobCommand, _super);
+    function DescribeKeyPhrasesDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeKeyPhrasesDetectionJobCommand.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 = "DescribeKeyPhrasesDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeKeyPhrasesDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeKeyPhrasesDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeKeyPhrasesDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeKeyPhrasesDetectionJobCommand(input, context);
+    };
+    DescribeKeyPhrasesDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeKeyPhrasesDetectionJobCommand(output, context);
+    };
+    return DescribeKeyPhrasesDetectionJobCommand;
+}($Command));
+export { DescribeKeyPhrasesDetectionJobCommand };

package/dist-es/commands/DescribePiiEntitiesDetectionJobCommand.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 { DescribePiiEntitiesDetectionJobRequest, DescribePiiEntitiesDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribePiiEntitiesDetectionJobCommand, serializeAws_json1_1DescribePiiEntitiesDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var DescribePiiEntitiesDetectionJobCommand = (function (_super) {
+    __extends(DescribePiiEntitiesDetectionJobCommand, _super);
+    function DescribePiiEntitiesDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribePiiEntitiesDetectionJobCommand.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 = "DescribePiiEntitiesDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribePiiEntitiesDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribePiiEntitiesDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribePiiEntitiesDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribePiiEntitiesDetectionJobCommand(input, context);
+    };
+    DescribePiiEntitiesDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribePiiEntitiesDetectionJobCommand(output, context);
+    };
+    return DescribePiiEntitiesDetectionJobCommand;
+}($Command));
+export { DescribePiiEntitiesDetectionJobCommand };

package/dist-es/commands/DescribeSentimentDetectionJobCommand.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 { DescribeSentimentDetectionJobRequest, DescribeSentimentDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribeSentimentDetectionJobCommand, serializeAws_json1_1DescribeSentimentDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var DescribeSentimentDetectionJobCommand = (function (_super) {
+    __extends(DescribeSentimentDetectionJobCommand, _super);
+    function DescribeSentimentDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeSentimentDetectionJobCommand.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 = "DescribeSentimentDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeSentimentDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeSentimentDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeSentimentDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeSentimentDetectionJobCommand(input, context);
+    };
+    DescribeSentimentDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeSentimentDetectionJobCommand(output, context);
+    };
+    return DescribeSentimentDetectionJobCommand;
+}($Command));
+export { DescribeSentimentDetectionJobCommand };

package/dist-es/commands/DescribeTopicsDetectionJobCommand.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 { DescribeTopicsDetectionJobRequest, DescribeTopicsDetectionJobResponse } from "../models/models_0";
+import { deserializeAws_json1_1DescribeTopicsDetectionJobCommand, serializeAws_json1_1DescribeTopicsDetectionJobCommand, } from "../protocols/Aws_json1_1";
+var DescribeTopicsDetectionJobCommand = (function (_super) {
+    __extends(DescribeTopicsDetectionJobCommand, _super);
+    function DescribeTopicsDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeTopicsDetectionJobCommand.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 = "DescribeTopicsDetectionJobCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeTopicsDetectionJobRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeTopicsDetectionJobResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeTopicsDetectionJobCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DescribeTopicsDetectionJobCommand(input, context);
+    };
+    DescribeTopicsDetectionJobCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DescribeTopicsDetectionJobCommand(output, context);
+    };
+    return DescribeTopicsDetectionJobCommand;
+}($Command));
+export { DescribeTopicsDetectionJobCommand };

package/dist-es/commands/DetectDominantLanguageCommand.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 { DetectDominantLanguageRequest, DetectDominantLanguageResponse } from "../models/models_0";
+import { deserializeAws_json1_1DetectDominantLanguageCommand, serializeAws_json1_1DetectDominantLanguageCommand, } from "../protocols/Aws_json1_1";
+var DetectDominantLanguageCommand = (function (_super) {
+    __extends(DetectDominantLanguageCommand, _super);
+    function DetectDominantLanguageCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DetectDominantLanguageCommand.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 = "DetectDominantLanguageCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DetectDominantLanguageRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DetectDominantLanguageResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DetectDominantLanguageCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DetectDominantLanguageCommand(input, context);
+    };
+    DetectDominantLanguageCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DetectDominantLanguageCommand(output, context);
+    };
+    return DetectDominantLanguageCommand;
+}($Command));
+export { DetectDominantLanguageCommand };

package/dist-es/commands/DetectEntitiesCommand.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 { DetectEntitiesRequest, DetectEntitiesResponse } from "../models/models_0";
+import { deserializeAws_json1_1DetectEntitiesCommand, serializeAws_json1_1DetectEntitiesCommand, } from "../protocols/Aws_json1_1";
+var DetectEntitiesCommand = (function (_super) {
+    __extends(DetectEntitiesCommand, _super);
+    function DetectEntitiesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DetectEntitiesCommand.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 = "DetectEntitiesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DetectEntitiesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DetectEntitiesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DetectEntitiesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DetectEntitiesCommand(input, context);
+    };
+    DetectEntitiesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DetectEntitiesCommand(output, context);
+    };
+    return DetectEntitiesCommand;
+}($Command));
+export { DetectEntitiesCommand };

package/dist-es/commands/DetectKeyPhrasesCommand.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 { DetectKeyPhrasesRequest, DetectKeyPhrasesResponse } from "../models/models_0";
+import { deserializeAws_json1_1DetectKeyPhrasesCommand, serializeAws_json1_1DetectKeyPhrasesCommand, } from "../protocols/Aws_json1_1";
+var DetectKeyPhrasesCommand = (function (_super) {
+    __extends(DetectKeyPhrasesCommand, _super);
+    function DetectKeyPhrasesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DetectKeyPhrasesCommand.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 = "DetectKeyPhrasesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DetectKeyPhrasesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DetectKeyPhrasesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DetectKeyPhrasesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DetectKeyPhrasesCommand(input, context);
+    };
+    DetectKeyPhrasesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DetectKeyPhrasesCommand(output, context);
+    };
+    return DetectKeyPhrasesCommand;
+}($Command));
+export { DetectKeyPhrasesCommand };

package/dist-es/commands/DetectPiiEntitiesCommand.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 { DetectPiiEntitiesRequest, DetectPiiEntitiesResponse } from "../models/models_0";
+import { deserializeAws_json1_1DetectPiiEntitiesCommand, serializeAws_json1_1DetectPiiEntitiesCommand, } from "../protocols/Aws_json1_1";
+var DetectPiiEntitiesCommand = (function (_super) {
+    __extends(DetectPiiEntitiesCommand, _super);
+    function DetectPiiEntitiesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DetectPiiEntitiesCommand.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 = "DetectPiiEntitiesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DetectPiiEntitiesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DetectPiiEntitiesResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DetectPiiEntitiesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DetectPiiEntitiesCommand(input, context);
+    };
+    DetectPiiEntitiesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DetectPiiEntitiesCommand(output, context);
+    };
+    return DetectPiiEntitiesCommand;
+}($Command));
+export { DetectPiiEntitiesCommand };

package/dist-es/commands/DetectSentimentCommand.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 { DetectSentimentRequest, DetectSentimentResponse } from "../models/models_0";
+import { deserializeAws_json1_1DetectSentimentCommand, serializeAws_json1_1DetectSentimentCommand, } from "../protocols/Aws_json1_1";
+var DetectSentimentCommand = (function (_super) {
+    __extends(DetectSentimentCommand, _super);
+    function DetectSentimentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DetectSentimentCommand.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 = "DetectSentimentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DetectSentimentRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DetectSentimentResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DetectSentimentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DetectSentimentCommand(input, context);
+    };
+    DetectSentimentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DetectSentimentCommand(output, context);
+    };
+    return DetectSentimentCommand;
+}($Command));
+export { DetectSentimentCommand };

package/dist-es/commands/DetectSyntaxCommand.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 { DetectSyntaxRequest, DetectSyntaxResponse } from "../models/models_0";
+import { deserializeAws_json1_1DetectSyntaxCommand, serializeAws_json1_1DetectSyntaxCommand, } from "../protocols/Aws_json1_1";
+var DetectSyntaxCommand = (function (_super) {
+    __extends(DetectSyntaxCommand, _super);
+    function DetectSyntaxCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DetectSyntaxCommand.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 = "DetectSyntaxCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DetectSyntaxRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DetectSyntaxResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DetectSyntaxCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1DetectSyntaxCommand(input, context);
+    };
+    DetectSyntaxCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1DetectSyntaxCommand(output, context);
+    };
+    return DetectSyntaxCommand;
+}($Command));
+export { DetectSyntaxCommand };

package/dist-es/commands/ListDocumentClassificationJobsCommand.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 { ListDocumentClassificationJobsRequest, ListDocumentClassificationJobsResponse } from "../models/models_0";
+import { deserializeAws_json1_1ListDocumentClassificationJobsCommand, serializeAws_json1_1ListDocumentClassificationJobsCommand, } from "../protocols/Aws_json1_1";
+var ListDocumentClassificationJobsCommand = (function (_super) {
+    __extends(ListDocumentClassificationJobsCommand, _super);
+    function ListDocumentClassificationJobsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListDocumentClassificationJobsCommand.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 = "ListDocumentClassificationJobsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListDocumentClassificationJobsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ListDocumentClassificationJobsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListDocumentClassificationJobsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_1ListDocumentClassificationJobsCommand(input, context);
+    };
+    ListDocumentClassificationJobsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_1ListDocumentClassificationJobsCommand(output, context);
+    };
+    return ListDocumentClassificationJobsCommand;
+}($Command));
+export { ListDocumentClassificationJobsCommand };