@aws-sdk/client-comprehend 3.183.0 → 3.185.0

package/dist-es/commands/DetectEntitiesCommand.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 { DetectEntitiesRequestFilterSensitiveLog, DetectEntitiesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DetectEntitiesCommand, serializeAws_json1_1DetectEntitiesCommand, } from "../protocols/Aws_json1_1";
-export class DetectEntitiesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DetectEntitiesCommand = (function (_super) {
+    __extends(DetectEntitiesCommand, _super);
+    function DetectEntitiesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DetectEntitiesCommand.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 = "DetectEntitiesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DetectEntitiesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DetectEntitiesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DetectEntitiesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DetectEntitiesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DetectEntitiesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DetectEntitiesCommand(output, context);
-    }
-}
+    };
+    return DetectEntitiesCommand;
+}($Command));
+export { DetectEntitiesCommand };

package/dist-es/commands/DetectKeyPhrasesCommand.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 { DetectKeyPhrasesRequestFilterSensitiveLog, DetectKeyPhrasesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DetectKeyPhrasesCommand, serializeAws_json1_1DetectKeyPhrasesCommand, } from "../protocols/Aws_json1_1";
-export class DetectKeyPhrasesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DetectKeyPhrasesCommand = (function (_super) {
+    __extends(DetectKeyPhrasesCommand, _super);
+    function DetectKeyPhrasesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DetectKeyPhrasesCommand.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 = "DetectKeyPhrasesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DetectKeyPhrasesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DetectKeyPhrasesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DetectKeyPhrasesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DetectKeyPhrasesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DetectKeyPhrasesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DetectKeyPhrasesCommand(output, context);
-    }
-}
+    };
+    return DetectKeyPhrasesCommand;
+}($Command));
+export { DetectKeyPhrasesCommand };

package/dist-es/commands/DetectPiiEntitiesCommand.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 { DetectPiiEntitiesRequestFilterSensitiveLog, DetectPiiEntitiesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DetectPiiEntitiesCommand, serializeAws_json1_1DetectPiiEntitiesCommand, } from "../protocols/Aws_json1_1";
-export class DetectPiiEntitiesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DetectPiiEntitiesCommand = (function (_super) {
+    __extends(DetectPiiEntitiesCommand, _super);
+    function DetectPiiEntitiesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DetectPiiEntitiesCommand.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 = "DetectPiiEntitiesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DetectPiiEntitiesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DetectPiiEntitiesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DetectPiiEntitiesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DetectPiiEntitiesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DetectPiiEntitiesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DetectPiiEntitiesCommand(output, context);
-    }
-}
+    };
+    return DetectPiiEntitiesCommand;
+}($Command));
+export { DetectPiiEntitiesCommand };

package/dist-es/commands/DetectSentimentCommand.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 { DetectSentimentRequestFilterSensitiveLog, DetectSentimentResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DetectSentimentCommand, serializeAws_json1_1DetectSentimentCommand, } from "../protocols/Aws_json1_1";
-export class DetectSentimentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DetectSentimentCommand = (function (_super) {
+    __extends(DetectSentimentCommand, _super);
+    function DetectSentimentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DetectSentimentCommand.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 = "DetectSentimentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DetectSentimentRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DetectSentimentResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DetectSentimentCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DetectSentimentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DetectSentimentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DetectSentimentCommand(output, context);
-    }
-}
+    };
+    return DetectSentimentCommand;
+}($Command));
+export { DetectSentimentCommand };

package/dist-es/commands/DetectSyntaxCommand.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 { DetectSyntaxRequestFilterSensitiveLog, DetectSyntaxResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DetectSyntaxCommand, serializeAws_json1_1DetectSyntaxCommand, } from "../protocols/Aws_json1_1";
-export class DetectSyntaxCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DetectSyntaxCommand = (function (_super) {
+    __extends(DetectSyntaxCommand, _super);
+    function DetectSyntaxCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DetectSyntaxCommand.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 = "DetectSyntaxCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: DetectSyntaxRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DetectSyntaxResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DetectSyntaxCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DetectSyntaxCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DetectSyntaxCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DetectSyntaxCommand(output, context);
-    }
-}
+    };
+    return DetectSyntaxCommand;
+}($Command));
+export { DetectSyntaxCommand };

package/dist-es/commands/DetectTargetedSentimentCommand.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 { DetectTargetedSentimentRequestFilterSensitiveLog, DetectTargetedSentimentResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DetectTargetedSentimentCommand, serializeAws_json1_1DetectTargetedSentimentCommand, } from "../protocols/Aws_json1_1";
-export class DetectTargetedSentimentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DetectTargetedSentimentCommand = (function (_super) {
+    __extends(DetectTargetedSentimentCommand, _super);
+    function DetectTargetedSentimentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DetectTargetedSentimentCommand.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 = "DetectTargetedSentimentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "DetectTargetedSentimentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DetectTargetedSentimentRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DetectTargetedSentimentResponseFilterSensitiveLog,
         };
-        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);
+    };
+    DetectTargetedSentimentCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DetectTargetedSentimentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DetectTargetedSentimentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DetectTargetedSentimentCommand(output, context);
-    }
-}
+    };
+    return DetectTargetedSentimentCommand;
+}($Command));
+export { DetectTargetedSentimentCommand };

package/dist-es/commands/ImportModelCommand.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 { ImportModelRequestFilterSensitiveLog, ImportModelResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ImportModelCommand, serializeAws_json1_1ImportModelCommand, } from "../protocols/Aws_json1_1";
-export class ImportModelCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ImportModelCommand = (function (_super) {
+    __extends(ImportModelCommand, _super);
+    function ImportModelCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ImportModelCommand.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 = "ImportModelCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "ImportModelCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ImportModelRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ImportModelResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ImportModelCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ImportModelCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ImportModelCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ImportModelCommand(output, context);
-    }
-}
+    };
+    return ImportModelCommand;
+}($Command));
+export { ImportModelCommand };

package/dist-es/commands/ListDocumentClassificationJobsCommand.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 { ListDocumentClassificationJobsRequestFilterSensitiveLog, ListDocumentClassificationJobsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListDocumentClassificationJobsCommand, serializeAws_json1_1ListDocumentClassificationJobsCommand, } from "../protocols/Aws_json1_1";
-export class ListDocumentClassificationJobsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListDocumentClassificationJobsCommand = (function (_super) {
+    __extends(ListDocumentClassificationJobsCommand, _super);
+    function ListDocumentClassificationJobsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListDocumentClassificationJobsCommand.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 = "ListDocumentClassificationJobsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        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: ListDocumentClassificationJobsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListDocumentClassificationJobsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListDocumentClassificationJobsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ListDocumentClassificationJobsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListDocumentClassificationJobsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListDocumentClassificationJobsCommand(output, context);
-    }
-}
+    };
+    return ListDocumentClassificationJobsCommand;
+}($Command));
+export { ListDocumentClassificationJobsCommand };

package/dist-es/commands/ListDocumentClassifierSummariesCommand.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 { ListDocumentClassifierSummariesRequestFilterSensitiveLog, ListDocumentClassifierSummariesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListDocumentClassifierSummariesCommand, serializeAws_json1_1ListDocumentClassifierSummariesCommand, } from "../protocols/Aws_json1_1";
-export class ListDocumentClassifierSummariesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListDocumentClassifierSummariesCommand = (function (_super) {
+    __extends(ListDocumentClassifierSummariesCommand, _super);
+    function ListDocumentClassifierSummariesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListDocumentClassifierSummariesCommand.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 = "ListDocumentClassifierSummariesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "ListDocumentClassifierSummariesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListDocumentClassifierSummariesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListDocumentClassifierSummariesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListDocumentClassifierSummariesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ListDocumentClassifierSummariesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListDocumentClassifierSummariesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListDocumentClassifierSummariesCommand(output, context);
-    }
-}
+    };
+    return ListDocumentClassifierSummariesCommand;
+}($Command));
+export { ListDocumentClassifierSummariesCommand };

package/dist-es/commands/ListDocumentClassifiersCommand.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 { ListDocumentClassifiersRequestFilterSensitiveLog, ListDocumentClassifiersResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1ListDocumentClassifiersCommand, serializeAws_json1_1ListDocumentClassifiersCommand, } from "../protocols/Aws_json1_1";
-export class ListDocumentClassifiersCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListDocumentClassifiersCommand = (function (_super) {
+    __extends(ListDocumentClassifiersCommand, _super);
+    function ListDocumentClassifiersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListDocumentClassifiersCommand.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 = "ListDocumentClassifiersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ComprehendClient";
+        var commandName = "ListDocumentClassifiersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListDocumentClassifiersRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListDocumentClassifiersResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListDocumentClassifiersCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1ListDocumentClassifiersCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListDocumentClassifiersCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1ListDocumentClassifiersCommand(output, context);
-    }
-}
+    };
+    return ListDocumentClassifiersCommand;
+}($Command));
+export { ListDocumentClassifiersCommand };