@aws-sdk/client-rekognition 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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