@aws-sdk/client-mturk 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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