@aws-sdk/client-rekognition 3.186.0 → 3.188.0

package/dist-es/commands/StartFaceDetectionCommand.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 { StartFaceDetectionRequestFilterSensitiveLog, StartFaceDetectionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StartFaceDetectionCommand, serializeAws_json1_1StartFaceDetectionCommand, } from "../protocols/Aws_json1_1";
-var StartFaceDetectionCommand = (function (_super) {
-    __extends(StartFaceDetectionCommand, _super);
-    function StartFaceDetectionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StartFaceDetectionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StartFaceDetectionCommand.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 = "RekognitionClient";
-        var commandName = "StartFaceDetectionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionClient";
+        const commandName = "StartFaceDetectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StartFaceDetectionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartFaceDetectionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StartFaceDetectionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1StartFaceDetectionCommand(input, context);
-    };
-    StartFaceDetectionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1StartFaceDetectionCommand(output, context);
-    };
-    return StartFaceDetectionCommand;
-}($Command));
-export { StartFaceDetectionCommand };
+    }
+}

package/dist-es/commands/StartFaceSearchCommand.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 { StartFaceSearchRequestFilterSensitiveLog, StartFaceSearchResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StartFaceSearchCommand, serializeAws_json1_1StartFaceSearchCommand, } from "../protocols/Aws_json1_1";
-var StartFaceSearchCommand = (function (_super) {
-    __extends(StartFaceSearchCommand, _super);
-    function StartFaceSearchCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StartFaceSearchCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StartFaceSearchCommand.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 = "RekognitionClient";
-        var commandName = "StartFaceSearchCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionClient";
+        const commandName = "StartFaceSearchCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StartFaceSearchRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartFaceSearchResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StartFaceSearchCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1StartFaceSearchCommand(input, context);
-    };
-    StartFaceSearchCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1StartFaceSearchCommand(output, context);
-    };
-    return StartFaceSearchCommand;
-}($Command));
-export { StartFaceSearchCommand };
+    }
+}

package/dist-es/commands/StartLabelDetectionCommand.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 { StartLabelDetectionRequestFilterSensitiveLog, StartLabelDetectionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StartLabelDetectionCommand, serializeAws_json1_1StartLabelDetectionCommand, } from "../protocols/Aws_json1_1";
-var StartLabelDetectionCommand = (function (_super) {
-    __extends(StartLabelDetectionCommand, _super);
-    function StartLabelDetectionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StartLabelDetectionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StartLabelDetectionCommand.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 = "RekognitionClient";
-        var commandName = "StartLabelDetectionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionClient";
+        const commandName = "StartLabelDetectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StartLabelDetectionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartLabelDetectionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StartLabelDetectionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1StartLabelDetectionCommand(input, context);
-    };
-    StartLabelDetectionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1StartLabelDetectionCommand(output, context);
-    };
-    return StartLabelDetectionCommand;
-}($Command));
-export { StartLabelDetectionCommand };
+    }
+}

package/dist-es/commands/StartPersonTrackingCommand.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 { StartPersonTrackingRequestFilterSensitiveLog, StartPersonTrackingResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StartPersonTrackingCommand, serializeAws_json1_1StartPersonTrackingCommand, } from "../protocols/Aws_json1_1";
-var StartPersonTrackingCommand = (function (_super) {
-    __extends(StartPersonTrackingCommand, _super);
-    function StartPersonTrackingCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StartPersonTrackingCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StartPersonTrackingCommand.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 = "RekognitionClient";
-        var commandName = "StartPersonTrackingCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionClient";
+        const commandName = "StartPersonTrackingCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StartPersonTrackingRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartPersonTrackingResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StartPersonTrackingCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1StartPersonTrackingCommand(input, context);
-    };
-    StartPersonTrackingCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1StartPersonTrackingCommand(output, context);
-    };
-    return StartPersonTrackingCommand;
-}($Command));
-export { StartPersonTrackingCommand };
+    }
+}

package/dist-es/commands/StartProjectVersionCommand.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 { StartProjectVersionRequestFilterSensitiveLog, StartProjectVersionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StartProjectVersionCommand, serializeAws_json1_1StartProjectVersionCommand, } from "../protocols/Aws_json1_1";
-var StartProjectVersionCommand = (function (_super) {
-    __extends(StartProjectVersionCommand, _super);
-    function StartProjectVersionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StartProjectVersionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StartProjectVersionCommand.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 = "RekognitionClient";
-        var commandName = "StartProjectVersionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionClient";
+        const commandName = "StartProjectVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StartProjectVersionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartProjectVersionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StartProjectVersionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1StartProjectVersionCommand(input, context);
-    };
-    StartProjectVersionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1StartProjectVersionCommand(output, context);
-    };
-    return StartProjectVersionCommand;
-}($Command));
-export { StartProjectVersionCommand };
+    }
+}

package/dist-es/commands/StartSegmentDetectionCommand.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 { StartSegmentDetectionRequestFilterSensitiveLog, StartSegmentDetectionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StartSegmentDetectionCommand, serializeAws_json1_1StartSegmentDetectionCommand, } from "../protocols/Aws_json1_1";
-var StartSegmentDetectionCommand = (function (_super) {
-    __extends(StartSegmentDetectionCommand, _super);
-    function StartSegmentDetectionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StartSegmentDetectionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StartSegmentDetectionCommand.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 = "RekognitionClient";
-        var commandName = "StartSegmentDetectionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionClient";
+        const commandName = "StartSegmentDetectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StartSegmentDetectionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartSegmentDetectionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StartSegmentDetectionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1StartSegmentDetectionCommand(input, context);
-    };
-    StartSegmentDetectionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1StartSegmentDetectionCommand(output, context);
-    };
-    return StartSegmentDetectionCommand;
-}($Command));
-export { StartSegmentDetectionCommand };
+    }
+}

package/dist-es/commands/StartStreamProcessorCommand.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 { StartStreamProcessorRequestFilterSensitiveLog, StartStreamProcessorResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StartStreamProcessorCommand, serializeAws_json1_1StartStreamProcessorCommand, } from "../protocols/Aws_json1_1";
-var StartStreamProcessorCommand = (function (_super) {
-    __extends(StartStreamProcessorCommand, _super);
-    function StartStreamProcessorCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StartStreamProcessorCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StartStreamProcessorCommand.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 = "RekognitionClient";
-        var commandName = "StartStreamProcessorCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionClient";
+        const commandName = "StartStreamProcessorCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StartStreamProcessorRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartStreamProcessorResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StartStreamProcessorCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1StartStreamProcessorCommand(input, context);
-    };
-    StartStreamProcessorCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1StartStreamProcessorCommand(output, context);
-    };
-    return StartStreamProcessorCommand;
-}($Command));
-export { StartStreamProcessorCommand };
+    }
+}

package/dist-es/commands/StartTextDetectionCommand.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 { StartTextDetectionRequestFilterSensitiveLog, StartTextDetectionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StartTextDetectionCommand, serializeAws_json1_1StartTextDetectionCommand, } from "../protocols/Aws_json1_1";
-var StartTextDetectionCommand = (function (_super) {
-    __extends(StartTextDetectionCommand, _super);
-    function StartTextDetectionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StartTextDetectionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StartTextDetectionCommand.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 = "RekognitionClient";
-        var commandName = "StartTextDetectionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionClient";
+        const commandName = "StartTextDetectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StartTextDetectionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartTextDetectionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StartTextDetectionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1StartTextDetectionCommand(input, context);
-    };
-    StartTextDetectionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1StartTextDetectionCommand(output, context);
-    };
-    return StartTextDetectionCommand;
-}($Command));
-export { StartTextDetectionCommand };
+    }
+}

package/dist-es/commands/StopProjectVersionCommand.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 { StopProjectVersionRequestFilterSensitiveLog, StopProjectVersionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StopProjectVersionCommand, serializeAws_json1_1StopProjectVersionCommand, } from "../protocols/Aws_json1_1";
-var StopProjectVersionCommand = (function (_super) {
-    __extends(StopProjectVersionCommand, _super);
-    function StopProjectVersionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StopProjectVersionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StopProjectVersionCommand.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 = "RekognitionClient";
-        var commandName = "StopProjectVersionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionClient";
+        const commandName = "StopProjectVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StopProjectVersionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StopProjectVersionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StopProjectVersionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1StopProjectVersionCommand(input, context);
-    };
-    StopProjectVersionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1StopProjectVersionCommand(output, context);
-    };
-    return StopProjectVersionCommand;
-}($Command));
-export { StopProjectVersionCommand };
+    }
+}

package/dist-es/commands/StopStreamProcessorCommand.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 { StopStreamProcessorRequestFilterSensitiveLog, StopStreamProcessorResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1StopStreamProcessorCommand, serializeAws_json1_1StopStreamProcessorCommand, } from "../protocols/Aws_json1_1";
-var StopStreamProcessorCommand = (function (_super) {
-    __extends(StopStreamProcessorCommand, _super);
-    function StopStreamProcessorCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class StopStreamProcessorCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    StopStreamProcessorCommand.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 = "RekognitionClient";
-        var commandName = "StopStreamProcessorCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RekognitionClient";
+        const commandName = "StopStreamProcessorCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: StopStreamProcessorRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StopStreamProcessorResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    StopStreamProcessorCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_json1_1StopStreamProcessorCommand(input, context);
-    };
-    StopStreamProcessorCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_json1_1StopStreamProcessorCommand(output, context);
-    };
-    return StopStreamProcessorCommand;
-}($Command));
-export { StopStreamProcessorCommand };
+    }
+}