@aws-sdk/client-mturk 3.185.0 → 3.188.0

package/dist-es/MTurkClient.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
@@ -9,31 +8,26 @@ import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-sig
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
 import { Client as __Client, } from "@aws-sdk/smithy-client";
 import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
-var MTurkClient = (function (_super) {
-    __extends(MTurkClient, _super);
-    function MTurkClient(configuration) {
-        var _this = this;
-        var _config_0 = __getRuntimeConfig(configuration);
-        var _config_1 = resolveRegionConfig(_config_0);
-        var _config_2 = resolveEndpointsConfig(_config_1);
-        var _config_3 = resolveRetryConfig(_config_2);
-        var _config_4 = resolveHostHeaderConfig(_config_3);
-        var _config_5 = resolveAwsAuthConfig(_config_4);
-        var _config_6 = resolveUserAgentConfig(_config_5);
-        _this = _super.call(this, _config_6) || this;
-        _this.config = _config_6;
-        _this.middlewareStack.use(getRetryPlugin(_this.config));
-        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
-        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
-        _this.middlewareStack.use(getLoggerPlugin(_this.config));
-        _this.middlewareStack.use(getRecursionDetectionPlugin(_this.config));
-        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
-        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
-        return _this;
+export class MTurkClient extends __Client {
+    constructor(configuration) {
+        const _config_0 = __getRuntimeConfig(configuration);
+        const _config_1 = resolveRegionConfig(_config_0);
+        const _config_2 = resolveEndpointsConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveHostHeaderConfig(_config_3);
+        const _config_5 = resolveAwsAuthConfig(_config_4);
+        const _config_6 = resolveUserAgentConfig(_config_5);
+        super(_config_6);
+        this.config = _config_6;
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getAwsAuthPlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
     }
-    MTurkClient.prototype.destroy = function () {
-        _super.prototype.destroy.call(this);
-    };
-    return MTurkClient;
-}(__Client));
-export { MTurkClient };
+    destroy() {
+        super.destroy();
+    }
+}

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

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

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

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

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

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

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

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

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