@aws-sdk/client-comprehend 3.34.0 → 3.37.0

package/dist-es/ComprehendClient.js

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var ComprehendClient = (function (_super) {
+    __extends(ComprehendClient, _super);
+    function ComprehendClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    ComprehendClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return ComprehendClient;
+}(__Client));
+export { ComprehendClient };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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