@aws-sdk/client-rekognition 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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