@aws-sdk/client-comprehend 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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