@aws-sdk/client-comprehend 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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