@aws-sdk/client-comprehend 3.183.0 → 3.185.0

package/dist-es/commands/CreateEndpointCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateEndpointRequestFilterSensitiveLog, CreateEndpointResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateEndpointCommand, serializeAws_json1_1CreateEndpointCommand, } from "../protocols/Aws_json1_1";
-export class CreateEndpointCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateEndpointCommand = (function (_super) {
+    __extends(CreateEndpointCommand, _super);
+    function CreateEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateEndpointCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ComprehendClient";
-        const commandName = "CreateEndpointCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: CreateEndpointRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateEndpointResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    CreateEndpointCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateEndpointCommand(output, context);
-    }
-}
+    };
+    return CreateEndpointCommand;
+}($Command));
+export { CreateEndpointCommand };

package/dist-es/commands/CreateEntityRecognizerCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateEntityRecognizerRequestFilterSensitiveLog, CreateEntityRecognizerResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1CreateEntityRecognizerCommand, serializeAws_json1_1CreateEntityRecognizerCommand, } from "../protocols/Aws_json1_1";
-export class CreateEntityRecognizerCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateEntityRecognizerCommand = (function (_super) {
+    __extends(CreateEntityRecognizerCommand, _super);
+    function CreateEntityRecognizerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateEntityRecognizerCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ComprehendClient";
-        const commandName = "CreateEntityRecognizerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: CreateEntityRecognizerRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateEntityRecognizerResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    CreateEntityRecognizerCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1CreateEntityRecognizerCommand(output, context);
-    }
-}
+    };
+    return CreateEntityRecognizerCommand;
+}($Command));
+export { CreateEntityRecognizerCommand };

package/dist-es/commands/DeleteDocumentClassifierCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteDocumentClassifierRequestFilterSensitiveLog, DeleteDocumentClassifierResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteDocumentClassifierCommand, serializeAws_json1_1DeleteDocumentClassifierCommand, } from "../protocols/Aws_json1_1";
-export class DeleteDocumentClassifierCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteDocumentClassifierCommand = (function (_super) {
+    __extends(DeleteDocumentClassifierCommand, _super);
+    function DeleteDocumentClassifierCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteDocumentClassifierCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ComprehendClient";
-        const commandName = "DeleteDocumentClassifierCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DeleteDocumentClassifierRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteDocumentClassifierResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DeleteDocumentClassifierCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteDocumentClassifierCommand(output, context);
-    }
-}
+    };
+    return DeleteDocumentClassifierCommand;
+}($Command));
+export { DeleteDocumentClassifierCommand };

package/dist-es/commands/DeleteEndpointCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteEndpointRequestFilterSensitiveLog, DeleteEndpointResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteEndpointCommand, serializeAws_json1_1DeleteEndpointCommand, } from "../protocols/Aws_json1_1";
-export class DeleteEndpointCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteEndpointCommand = (function (_super) {
+    __extends(DeleteEndpointCommand, _super);
+    function DeleteEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteEndpointCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ComprehendClient";
-        const commandName = "DeleteEndpointCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DeleteEndpointRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteEndpointResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DeleteEndpointCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteEndpointCommand(output, context);
-    }
-}
+    };
+    return DeleteEndpointCommand;
+}($Command));
+export { DeleteEndpointCommand };

package/dist-es/commands/DeleteEntityRecognizerCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteEntityRecognizerRequestFilterSensitiveLog, DeleteEntityRecognizerResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteEntityRecognizerCommand, serializeAws_json1_1DeleteEntityRecognizerCommand, } from "../protocols/Aws_json1_1";
-export class DeleteEntityRecognizerCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteEntityRecognizerCommand = (function (_super) {
+    __extends(DeleteEntityRecognizerCommand, _super);
+    function DeleteEntityRecognizerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteEntityRecognizerCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ComprehendClient";
-        const commandName = "DeleteEntityRecognizerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DeleteEntityRecognizerRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteEntityRecognizerResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DeleteEntityRecognizerCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteEntityRecognizerCommand(output, context);
-    }
-}
+    };
+    return DeleteEntityRecognizerCommand;
+}($Command));
+export { DeleteEntityRecognizerCommand };

package/dist-es/commands/DeleteResourcePolicyCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteResourcePolicyRequestFilterSensitiveLog, DeleteResourcePolicyResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteResourcePolicyCommand, serializeAws_json1_1DeleteResourcePolicyCommand, } from "../protocols/Aws_json1_1";
-export class DeleteResourcePolicyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteResourcePolicyCommand = (function (_super) {
+    __extends(DeleteResourcePolicyCommand, _super);
+    function DeleteResourcePolicyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteResourcePolicyCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ComprehendClient";
-        const commandName = "DeleteResourcePolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "DeleteResourcePolicyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteResourcePolicyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteResourcePolicyResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteResourcePolicyCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteResourcePolicyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteResourcePolicyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteResourcePolicyCommand(output, context);
-    }
-}
+    };
+    return DeleteResourcePolicyCommand;
+}($Command));
+export { DeleteResourcePolicyCommand };

package/dist-es/commands/DescribeDocumentClassificationJobCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeDocumentClassificationJobRequestFilterSensitiveLog, DescribeDocumentClassificationJobResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeDocumentClassificationJobCommand, serializeAws_json1_1DescribeDocumentClassificationJobCommand, } from "../protocols/Aws_json1_1";
-export class DescribeDocumentClassificationJobCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeDocumentClassificationJobCommand = (function (_super) {
+    __extends(DescribeDocumentClassificationJobCommand, _super);
+    function DescribeDocumentClassificationJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeDocumentClassificationJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ComprehendClient";
-        const commandName = "DescribeDocumentClassificationJobCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DescribeDocumentClassificationJobRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeDocumentClassificationJobResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DescribeDocumentClassificationJobCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeDocumentClassificationJobCommand(output, context);
-    }
-}
+    };
+    return DescribeDocumentClassificationJobCommand;
+}($Command));
+export { DescribeDocumentClassificationJobCommand };

package/dist-es/commands/DescribeDocumentClassifierCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeDocumentClassifierRequestFilterSensitiveLog, DescribeDocumentClassifierResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeDocumentClassifierCommand, serializeAws_json1_1DescribeDocumentClassifierCommand, } from "../protocols/Aws_json1_1";
-export class DescribeDocumentClassifierCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeDocumentClassifierCommand = (function (_super) {
+    __extends(DescribeDocumentClassifierCommand, _super);
+    function DescribeDocumentClassifierCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeDocumentClassifierCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ComprehendClient";
-        const commandName = "DescribeDocumentClassifierCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DescribeDocumentClassifierRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeDocumentClassifierResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DescribeDocumentClassifierCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeDocumentClassifierCommand(output, context);
-    }
-}
+    };
+    return DescribeDocumentClassifierCommand;
+}($Command));
+export { DescribeDocumentClassifierCommand };

package/dist-es/commands/DescribeDominantLanguageDetectionJobCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeDominantLanguageDetectionJobRequestFilterSensitiveLog, DescribeDominantLanguageDetectionJobResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeDominantLanguageDetectionJobCommand, serializeAws_json1_1DescribeDominantLanguageDetectionJobCommand, } from "../protocols/Aws_json1_1";
-export class DescribeDominantLanguageDetectionJobCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeDominantLanguageDetectionJobCommand = (function (_super) {
+    __extends(DescribeDominantLanguageDetectionJobCommand, _super);
+    function DescribeDominantLanguageDetectionJobCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeDominantLanguageDetectionJobCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ComprehendClient";
-        const commandName = "DescribeDominantLanguageDetectionJobCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DescribeDominantLanguageDetectionJobRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeDominantLanguageDetectionJobResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DescribeDominantLanguageDetectionJobCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeDominantLanguageDetectionJobCommand(output, context);
-    }
-}
+    };
+    return DescribeDominantLanguageDetectionJobCommand;
+}($Command));
+export { DescribeDominantLanguageDetectionJobCommand };

package/dist-es/commands/DescribeEndpointCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeEndpointRequestFilterSensitiveLog, DescribeEndpointResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeEndpointCommand, serializeAws_json1_1DescribeEndpointCommand, } from "../protocols/Aws_json1_1";
-export class DescribeEndpointCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeEndpointCommand = (function (_super) {
+    __extends(DescribeEndpointCommand, _super);
+    function DescribeEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeEndpointCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ComprehendClient";
-        const commandName = "DescribeEndpointCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DescribeEndpointRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeEndpointResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        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);
-    }
-    deserialize(output, context) {
+    };
+    DescribeEndpointCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeEndpointCommand(output, context);
-    }
-}
+    };
+    return DescribeEndpointCommand;
+}($Command));
+export { DescribeEndpointCommand };