@aws-sdk/client-comprehend 3.181.0 → 3.183.0

package/dist-es/commands/StartTargetedSentimentDetectionJobCommand.js

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

package/dist-es/commands/StartTopicsDetectionJobCommand.js

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

package/dist-es/commands/StopDominantLanguageDetectionJobCommand.js

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

package/dist-es/commands/StopEntitiesDetectionJobCommand.js

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

package/dist-es/commands/StopEventsDetectionJobCommand.js

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

package/dist-es/commands/StopKeyPhrasesDetectionJobCommand.js

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

package/dist-es/commands/StopPiiEntitiesDetectionJobCommand.js

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

package/dist-es/commands/StopSentimentDetectionJobCommand.js

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

package/dist-es/commands/StopTargetedSentimentDetectionJobCommand.js

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

package/dist-es/commands/StopTrainingDocumentClassifierCommand.js

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