@aws-sdk/client-mturk 3.183.0 → 3.186.0

package/dist-es/MTurkClient.js

@@ -1,3 +1,4 @@
+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";
@@ -8,26 +9,31 @@ 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";
-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));
+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;
     }
-    destroy() {
-        super.destroy();
-    }
-}
+    MTurkClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return MTurkClient;
+}(__Client));
+export { MTurkClient };

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

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

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

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

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

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

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

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

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