@aws-sdk/client-mturk 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3098 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MTurkServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./MTurkClient"), exports);
-tslib_1.__exportStar(require("./MTurk"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var MTurkServiceException_1 = require("./models/MTurkServiceException");
-Object.defineProperty(exports, "MTurkServiceException", { enumerable: true, get: function () { return MTurkServiceException_1.MTurkServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AcceptQualificationRequestCommand: () => AcceptQualificationRequestCommand,
+  ApproveAssignmentCommand: () => ApproveAssignmentCommand,
+  AssignmentStatus: () => AssignmentStatus,
+  AssociateQualificationWithWorkerCommand: () => AssociateQualificationWithWorkerCommand,
+  Comparator: () => Comparator,
+  CreateAdditionalAssignmentsForHITCommand: () => CreateAdditionalAssignmentsForHITCommand,
+  CreateHITCommand: () => CreateHITCommand,
+  CreateHITTypeCommand: () => CreateHITTypeCommand,
+  CreateHITWithHITTypeCommand: () => CreateHITWithHITTypeCommand,
+  CreateQualificationTypeCommand: () => CreateQualificationTypeCommand,
+  CreateWorkerBlockCommand: () => CreateWorkerBlockCommand,
+  DeleteHITCommand: () => DeleteHITCommand,
+  DeleteQualificationTypeCommand: () => DeleteQualificationTypeCommand,
+  DeleteWorkerBlockCommand: () => DeleteWorkerBlockCommand,
+  DisassociateQualificationFromWorkerCommand: () => DisassociateQualificationFromWorkerCommand,
+  EventType: () => EventType,
+  GetAccountBalanceCommand: () => GetAccountBalanceCommand,
+  GetAssignmentCommand: () => GetAssignmentCommand,
+  GetFileUploadURLCommand: () => GetFileUploadURLCommand,
+  GetHITCommand: () => GetHITCommand,
+  GetQualificationScoreCommand: () => GetQualificationScoreCommand,
+  GetQualificationTypeCommand: () => GetQualificationTypeCommand,
+  HITAccessActions: () => HITAccessActions,
+  HITReviewStatus: () => HITReviewStatus,
+  HITStatus: () => HITStatus,
+  ListAssignmentsForHITCommand: () => ListAssignmentsForHITCommand,
+  ListBonusPaymentsCommand: () => ListBonusPaymentsCommand,
+  ListHITsCommand: () => ListHITsCommand,
+  ListHITsForQualificationTypeCommand: () => ListHITsForQualificationTypeCommand,
+  ListQualificationRequestsCommand: () => ListQualificationRequestsCommand,
+  ListQualificationTypesCommand: () => ListQualificationTypesCommand,
+  ListReviewPolicyResultsForHITCommand: () => ListReviewPolicyResultsForHITCommand,
+  ListReviewableHITsCommand: () => ListReviewableHITsCommand,
+  ListWorkerBlocksCommand: () => ListWorkerBlocksCommand,
+  ListWorkersWithQualificationTypeCommand: () => ListWorkersWithQualificationTypeCommand,
+  MTurk: () => MTurk,
+  MTurkClient: () => MTurkClient,
+  MTurkServiceException: () => MTurkServiceException,
+  NotificationTransport: () => NotificationTransport,
+  NotifyWorkersCommand: () => NotifyWorkersCommand,
+  NotifyWorkersFailureCode: () => NotifyWorkersFailureCode,
+  QualificationStatus: () => QualificationStatus,
+  QualificationTypeStatus: () => QualificationTypeStatus,
+  RejectAssignmentCommand: () => RejectAssignmentCommand,
+  RejectQualificationRequestCommand: () => RejectQualificationRequestCommand,
+  RequestError: () => RequestError,
+  ReviewActionStatus: () => ReviewActionStatus,
+  ReviewPolicyLevel: () => ReviewPolicyLevel,
+  ReviewableHITStatus: () => ReviewableHITStatus,
+  SendBonusCommand: () => SendBonusCommand,
+  SendTestEventNotificationCommand: () => SendTestEventNotificationCommand,
+  ServiceFault: () => ServiceFault,
+  UpdateExpirationForHITCommand: () => UpdateExpirationForHITCommand,
+  UpdateHITReviewStatusCommand: () => UpdateHITReviewStatusCommand,
+  UpdateHITTypeOfHITCommand: () => UpdateHITTypeOfHITCommand,
+  UpdateNotificationSettingsCommand: () => UpdateNotificationSettingsCommand,
+  UpdateQualificationTypeCommand: () => UpdateQualificationTypeCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateListAssignmentsForHIT: () => paginateListAssignmentsForHIT,
+  paginateListBonusPayments: () => paginateListBonusPayments,
+  paginateListHITs: () => paginateListHITs,
+  paginateListHITsForQualificationType: () => paginateListHITsForQualificationType,
+  paginateListQualificationRequests: () => paginateListQualificationRequests,
+  paginateListQualificationTypes: () => paginateListQualificationTypes,
+  paginateListReviewPolicyResultsForHIT: () => paginateListReviewPolicyResultsForHIT,
+  paginateListReviewableHITs: () => paginateListReviewableHITs,
+  paginateListWorkerBlocks: () => paginateListWorkerBlocks,
+  paginateListWorkersWithQualificationType: () => paginateListWorkersWithQualificationType
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/MTurkClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "mturk-requester"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/MTurkClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/MTurkClient.ts
+var _MTurkClient = class _MTurkClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_MTurkClient, "MTurkClient");
+var MTurkClient = _MTurkClient;
+
+// src/MTurk.ts
+
+
+// src/commands/AcceptQualificationRequestCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/MTurkServiceException.ts
+
+var _MTurkServiceException = class _MTurkServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _MTurkServiceException.prototype);
+  }
+};
+__name(_MTurkServiceException, "MTurkServiceException");
+var MTurkServiceException = _MTurkServiceException;
+
+// src/models/models_0.ts
+var _RequestError = class _RequestError extends MTurkServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "RequestError",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "RequestError";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _RequestError.prototype);
+    this.Message = opts.Message;
+    this.TurkErrorCode = opts.TurkErrorCode;
+  }
+};
+__name(_RequestError, "RequestError");
+var RequestError = _RequestError;
+var _ServiceFault = class _ServiceFault extends MTurkServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceFault",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServiceFault";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServiceFault.prototype);
+    this.Message = opts.Message;
+    this.TurkErrorCode = opts.TurkErrorCode;
+  }
+};
+__name(_ServiceFault, "ServiceFault");
+var ServiceFault = _ServiceFault;
+var AssignmentStatus = {
+  Approved: "Approved",
+  Rejected: "Rejected",
+  Submitted: "Submitted"
+};
+var Comparator = {
+  DoesNotExist: "DoesNotExist",
+  EqualTo: "EqualTo",
+  Exists: "Exists",
+  GreaterThan: "GreaterThan",
+  GreaterThanOrEqualTo: "GreaterThanOrEqualTo",
+  In: "In",
+  LessThan: "LessThan",
+  LessThanOrEqualTo: "LessThanOrEqualTo",
+  NotEqualTo: "NotEqualTo",
+  NotIn: "NotIn"
+};
+var HITAccessActions = {
+  Accept: "Accept",
+  DiscoverPreviewAndAccept: "DiscoverPreviewAndAccept",
+  PreviewAndAccept: "PreviewAndAccept"
+};
+var HITReviewStatus = {
+  MarkedForReview: "MarkedForReview",
+  NotReviewed: "NotReviewed",
+  ReviewedAppropriate: "ReviewedAppropriate",
+  ReviewedInappropriate: "ReviewedInappropriate"
+};
+var HITStatus = {
+  Assignable: "Assignable",
+  Disposed: "Disposed",
+  Reviewable: "Reviewable",
+  Reviewing: "Reviewing",
+  Unassignable: "Unassignable"
+};
+var QualificationTypeStatus = {
+  Active: "Active",
+  Inactive: "Inactive"
+};
+var EventType = {
+  AssignmentAbandoned: "AssignmentAbandoned",
+  AssignmentAccepted: "AssignmentAccepted",
+  AssignmentApproved: "AssignmentApproved",
+  AssignmentRejected: "AssignmentRejected",
+  AssignmentReturned: "AssignmentReturned",
+  AssignmentSubmitted: "AssignmentSubmitted",
+  HITCreated: "HITCreated",
+  HITDisposed: "HITDisposed",
+  HITExpired: "HITExpired",
+  HITExtended: "HITExtended",
+  HITReviewable: "HITReviewable",
+  Ping: "Ping"
+};
+var QualificationStatus = {
+  Granted: "Granted",
+  Revoked: "Revoked"
+};
+var ReviewableHITStatus = {
+  Reviewable: "Reviewable",
+  Reviewing: "Reviewing"
+};
+var ReviewPolicyLevel = {
+  Assignment: "Assignment",
+  HIT: "HIT"
+};
+var ReviewActionStatus = {
+  Cancelled: "Cancelled",
+  Failed: "Failed",
+  Intended: "Intended",
+  Succeeded: "Succeeded"
+};
+var NotifyWorkersFailureCode = {
+  HardFailure: "HardFailure",
+  SoftFailure: "SoftFailure"
+};
+var NotificationTransport = {
+  Email: "Email",
+  SNS: "SNS",
+  SQS: "SQS"
+};
+
+// src/protocols/Aws_json1_1.ts
+var se_AcceptQualificationRequestCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AcceptQualificationRequest");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AcceptQualificationRequestCommand");
+var se_ApproveAssignmentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ApproveAssignment");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ApproveAssignmentCommand");
+var se_AssociateQualificationWithWorkerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateQualificationWithWorker");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateQualificationWithWorkerCommand");
+var se_CreateAdditionalAssignmentsForHITCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateAdditionalAssignmentsForHIT");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateAdditionalAssignmentsForHITCommand");
+var se_CreateHITCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateHIT");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateHITCommand");
+var se_CreateHITTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateHITType");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateHITTypeCommand");
+var se_CreateHITWithHITTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateHITWithHITType");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateHITWithHITTypeCommand");
+var se_CreateQualificationTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateQualificationType");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateQualificationTypeCommand");
+var se_CreateWorkerBlockCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateWorkerBlock");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateWorkerBlockCommand");
+var se_DeleteHITCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteHIT");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteHITCommand");
+var se_DeleteQualificationTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteQualificationType");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteQualificationTypeCommand");
+var se_DeleteWorkerBlockCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteWorkerBlock");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteWorkerBlockCommand");
+var se_DisassociateQualificationFromWorkerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisassociateQualificationFromWorker");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisassociateQualificationFromWorkerCommand");
+var se_GetAccountBalanceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetAccountBalance");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetAccountBalanceCommand");
+var se_GetAssignmentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetAssignment");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetAssignmentCommand");
+var se_GetFileUploadURLCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetFileUploadURL");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetFileUploadURLCommand");
+var se_GetHITCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetHIT");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetHITCommand");
+var se_GetQualificationScoreCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetQualificationScore");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetQualificationScoreCommand");
+var se_GetQualificationTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetQualificationType");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetQualificationTypeCommand");
+var se_ListAssignmentsForHITCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListAssignmentsForHIT");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListAssignmentsForHITCommand");
+var se_ListBonusPaymentsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListBonusPayments");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListBonusPaymentsCommand");
+var se_ListHITsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListHITs");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListHITsCommand");
+var se_ListHITsForQualificationTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListHITsForQualificationType");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListHITsForQualificationTypeCommand");
+var se_ListQualificationRequestsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListQualificationRequests");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListQualificationRequestsCommand");
+var se_ListQualificationTypesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListQualificationTypes");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListQualificationTypesCommand");
+var se_ListReviewableHITsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListReviewableHITs");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListReviewableHITsCommand");
+var se_ListReviewPolicyResultsForHITCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListReviewPolicyResultsForHIT");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListReviewPolicyResultsForHITCommand");
+var se_ListWorkerBlocksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListWorkerBlocks");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListWorkerBlocksCommand");
+var se_ListWorkersWithQualificationTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListWorkersWithQualificationType");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListWorkersWithQualificationTypeCommand");
+var se_NotifyWorkersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("NotifyWorkers");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_NotifyWorkersCommand");
+var se_RejectAssignmentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RejectAssignment");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RejectAssignmentCommand");
+var se_RejectQualificationRequestCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RejectQualificationRequest");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RejectQualificationRequestCommand");
+var se_SendBonusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SendBonus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SendBonusCommand");
+var se_SendTestEventNotificationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SendTestEventNotification");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SendTestEventNotificationCommand");
+var se_UpdateExpirationForHITCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateExpirationForHIT");
+  let body;
+  body = JSON.stringify(se_UpdateExpirationForHITRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateExpirationForHITCommand");
+var se_UpdateHITReviewStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateHITReviewStatus");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateHITReviewStatusCommand");
+var se_UpdateHITTypeOfHITCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateHITTypeOfHIT");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateHITTypeOfHITCommand");
+var se_UpdateNotificationSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateNotificationSettings");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateNotificationSettingsCommand");
+var se_UpdateQualificationTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateQualificationType");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateQualificationTypeCommand");
+var de_AcceptQualificationRequestCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AcceptQualificationRequestCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AcceptQualificationRequestCommand");
+var de_AcceptQualificationRequestCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AcceptQualificationRequestCommandError");
+var de_ApproveAssignmentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ApproveAssignmentCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ApproveAssignmentCommand");
+var de_ApproveAssignmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ApproveAssignmentCommandError");
+var de_AssociateQualificationWithWorkerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateQualificationWithWorkerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AssociateQualificationWithWorkerCommand");
+var de_AssociateQualificationWithWorkerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateQualificationWithWorkerCommandError");
+var de_CreateAdditionalAssignmentsForHITCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateAdditionalAssignmentsForHITCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateAdditionalAssignmentsForHITCommand");
+var de_CreateAdditionalAssignmentsForHITCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAdditionalAssignmentsForHITCommandError");
+var de_CreateHITCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateHITCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateHITResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateHITCommand");
+var de_CreateHITCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateHITCommandError");
+var de_CreateHITTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateHITTypeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateHITTypeCommand");
+var de_CreateHITTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateHITTypeCommandError");
+var de_CreateHITWithHITTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateHITWithHITTypeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateHITWithHITTypeResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateHITWithHITTypeCommand");
+var de_CreateHITWithHITTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateHITWithHITTypeCommandError");
+var de_CreateQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateQualificationTypeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateQualificationTypeResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateQualificationTypeCommand");
+var de_CreateQualificationTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateQualificationTypeCommandError");
+var de_CreateWorkerBlockCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateWorkerBlockCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateWorkerBlockCommand");
+var de_CreateWorkerBlockCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateWorkerBlockCommandError");
+var de_DeleteHITCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteHITCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteHITCommand");
+var de_DeleteHITCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteHITCommandError");
+var de_DeleteQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteQualificationTypeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteQualificationTypeCommand");
+var de_DeleteQualificationTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteQualificationTypeCommandError");
+var de_DeleteWorkerBlockCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteWorkerBlockCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteWorkerBlockCommand");
+var de_DeleteWorkerBlockCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteWorkerBlockCommandError");
+var de_DisassociateQualificationFromWorkerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisassociateQualificationFromWorkerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DisassociateQualificationFromWorkerCommand");
+var de_DisassociateQualificationFromWorkerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisassociateQualificationFromWorkerCommandError");
+var de_GetAccountBalanceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetAccountBalanceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetAccountBalanceCommand");
+var de_GetAccountBalanceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAccountBalanceCommandError");
+var de_GetAssignmentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetAssignmentCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetAssignmentResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetAssignmentCommand");
+var de_GetAssignmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetAssignmentCommandError");
+var de_GetFileUploadURLCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetFileUploadURLCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetFileUploadURLCommand");
+var de_GetFileUploadURLCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetFileUploadURLCommandError");
+var de_GetHITCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetHITCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetHITResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetHITCommand");
+var de_GetHITCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetHITCommandError");
+var de_GetQualificationScoreCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetQualificationScoreCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetQualificationScoreResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetQualificationScoreCommand");
+var de_GetQualificationScoreCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetQualificationScoreCommandError");
+var de_GetQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetQualificationTypeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetQualificationTypeResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetQualificationTypeCommand");
+var de_GetQualificationTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetQualificationTypeCommandError");
+var de_ListAssignmentsForHITCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListAssignmentsForHITCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListAssignmentsForHITResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListAssignmentsForHITCommand");
+var de_ListAssignmentsForHITCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListAssignmentsForHITCommandError");
+var de_ListBonusPaymentsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListBonusPaymentsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListBonusPaymentsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListBonusPaymentsCommand");
+var de_ListBonusPaymentsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListBonusPaymentsCommandError");
+var de_ListHITsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListHITsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListHITsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListHITsCommand");
+var de_ListHITsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListHITsCommandError");
+var de_ListHITsForQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListHITsForQualificationTypeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListHITsForQualificationTypeResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListHITsForQualificationTypeCommand");
+var de_ListHITsForQualificationTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListHITsForQualificationTypeCommandError");
+var de_ListQualificationRequestsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListQualificationRequestsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListQualificationRequestsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListQualificationRequestsCommand");
+var de_ListQualificationRequestsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListQualificationRequestsCommandError");
+var de_ListQualificationTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListQualificationTypesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListQualificationTypesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListQualificationTypesCommand");
+var de_ListQualificationTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListQualificationTypesCommandError");
+var de_ListReviewableHITsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListReviewableHITsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListReviewableHITsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListReviewableHITsCommand");
+var de_ListReviewableHITsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListReviewableHITsCommandError");
+var de_ListReviewPolicyResultsForHITCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListReviewPolicyResultsForHITCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListReviewPolicyResultsForHITResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListReviewPolicyResultsForHITCommand");
+var de_ListReviewPolicyResultsForHITCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListReviewPolicyResultsForHITCommandError");
+var de_ListWorkerBlocksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListWorkerBlocksCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListWorkerBlocksCommand");
+var de_ListWorkerBlocksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListWorkerBlocksCommandError");
+var de_ListWorkersWithQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListWorkersWithQualificationTypeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListWorkersWithQualificationTypeResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListWorkersWithQualificationTypeCommand");
+var de_ListWorkersWithQualificationTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListWorkersWithQualificationTypeCommandError");
+var de_NotifyWorkersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_NotifyWorkersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_NotifyWorkersCommand");
+var de_NotifyWorkersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_NotifyWorkersCommandError");
+var de_RejectAssignmentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RejectAssignmentCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RejectAssignmentCommand");
+var de_RejectAssignmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RejectAssignmentCommandError");
+var de_RejectQualificationRequestCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RejectQualificationRequestCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RejectQualificationRequestCommand");
+var de_RejectQualificationRequestCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RejectQualificationRequestCommandError");
+var de_SendBonusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SendBonusCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SendBonusCommand");
+var de_SendBonusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SendBonusCommandError");
+var de_SendTestEventNotificationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SendTestEventNotificationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SendTestEventNotificationCommand");
+var de_SendTestEventNotificationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SendTestEventNotificationCommandError");
+var de_UpdateExpirationForHITCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateExpirationForHITCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateExpirationForHITCommand");
+var de_UpdateExpirationForHITCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateExpirationForHITCommandError");
+var de_UpdateHITReviewStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateHITReviewStatusCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateHITReviewStatusCommand");
+var de_UpdateHITReviewStatusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateHITReviewStatusCommandError");
+var de_UpdateHITTypeOfHITCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateHITTypeOfHITCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateHITTypeOfHITCommand");
+var de_UpdateHITTypeOfHITCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateHITTypeOfHITCommandError");
+var de_UpdateNotificationSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateNotificationSettingsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateNotificationSettingsCommand");
+var de_UpdateNotificationSettingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateNotificationSettingsCommandError");
+var de_UpdateQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateQualificationTypeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateQualificationTypeResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateQualificationTypeCommand");
+var de_UpdateQualificationTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "RequestError":
+    case "com.amazonaws.mturk#RequestError":
+      throw await de_RequestErrorRes(parsedOutput, context);
+    case "ServiceFault":
+    case "com.amazonaws.mturk#ServiceFault":
+      throw await de_ServiceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateQualificationTypeCommandError");
+var de_RequestErrorRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new RequestError({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_RequestErrorRes");
+var de_ServiceFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceFaultRes");
+var se_UpdateExpirationForHITRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    ExpireAt: (_) => Math.round(_.getTime() / 1e3),
+    HITId: []
+  });
+}, "se_UpdateExpirationForHITRequest");
+var de_Assignment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AcceptTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Answer: import_smithy_client.expectString,
+    ApprovalTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    AssignmentId: import_smithy_client.expectString,
+    AssignmentStatus: import_smithy_client.expectString,
+    AutoApprovalTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Deadline: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    HITId: import_smithy_client.expectString,
+    RejectionTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    RequesterFeedback: import_smithy_client.expectString,
+    SubmitTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    WorkerId: import_smithy_client.expectString
+  });
+}, "de_Assignment");
+var de_AssignmentList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Assignment(entry, context);
+  });
+  return retVal;
+}, "de_AssignmentList");
+var de_BonusPayment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AssignmentId: import_smithy_client.expectString,
+    BonusAmount: import_smithy_client.expectString,
+    GrantTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Reason: import_smithy_client.expectString,
+    WorkerId: import_smithy_client.expectString
+  });
+}, "de_BonusPayment");
+var de_BonusPaymentList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_BonusPayment(entry, context);
+  });
+  return retVal;
+}, "de_BonusPaymentList");
+var de_CreateHITResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    HIT: (_) => de_HIT(_, context)
+  });
+}, "de_CreateHITResponse");
+var de_CreateHITWithHITTypeResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    HIT: (_) => de_HIT(_, context)
+  });
+}, "de_CreateHITWithHITTypeResponse");
+var de_CreateQualificationTypeResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    QualificationType: (_) => de_QualificationType(_, context)
+  });
+}, "de_CreateQualificationTypeResponse");
+var de_GetAssignmentResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Assignment: (_) => de_Assignment(_, context),
+    HIT: (_) => de_HIT(_, context)
+  });
+}, "de_GetAssignmentResponse");
+var de_GetHITResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    HIT: (_) => de_HIT(_, context)
+  });
+}, "de_GetHITResponse");
+var de_GetQualificationScoreResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Qualification: (_) => de_Qualification(_, context)
+  });
+}, "de_GetQualificationScoreResponse");
+var de_GetQualificationTypeResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    QualificationType: (_) => de_QualificationType(_, context)
+  });
+}, "de_GetQualificationTypeResponse");
+var de_HIT = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AssignmentDurationInSeconds: import_smithy_client.expectLong,
+    AutoApprovalDelayInSeconds: import_smithy_client.expectLong,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Description: import_smithy_client.expectString,
+    Expiration: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    HITGroupId: import_smithy_client.expectString,
+    HITId: import_smithy_client.expectString,
+    HITLayoutId: import_smithy_client.expectString,
+    HITReviewStatus: import_smithy_client.expectString,
+    HITStatus: import_smithy_client.expectString,
+    HITTypeId: import_smithy_client.expectString,
+    Keywords: import_smithy_client.expectString,
+    MaxAssignments: import_smithy_client.expectInt32,
+    NumberOfAssignmentsAvailable: import_smithy_client.expectInt32,
+    NumberOfAssignmentsCompleted: import_smithy_client.expectInt32,
+    NumberOfAssignmentsPending: import_smithy_client.expectInt32,
+    QualificationRequirements: import_smithy_client._json,
+    Question: import_smithy_client.expectString,
+    RequesterAnnotation: import_smithy_client.expectString,
+    Reward: import_smithy_client.expectString,
+    Title: import_smithy_client.expectString
+  });
+}, "de_HIT");
+var de_HITList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_HIT(entry, context);
+  });
+  return retVal;
+}, "de_HITList");
+var de_ListAssignmentsForHITResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Assignments: (_) => de_AssignmentList(_, context),
+    NextToken: import_smithy_client.expectString,
+    NumResults: import_smithy_client.expectInt32
+  });
+}, "de_ListAssignmentsForHITResponse");
+var de_ListBonusPaymentsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BonusPayments: (_) => de_BonusPaymentList(_, context),
+    NextToken: import_smithy_client.expectString,
+    NumResults: import_smithy_client.expectInt32
+  });
+}, "de_ListBonusPaymentsResponse");
+var de_ListHITsForQualificationTypeResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    HITs: (_) => de_HITList(_, context),
+    NextToken: import_smithy_client.expectString,
+    NumResults: import_smithy_client.expectInt32
+  });
+}, "de_ListHITsForQualificationTypeResponse");
+var de_ListHITsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    HITs: (_) => de_HITList(_, context),
+    NextToken: import_smithy_client.expectString,
+    NumResults: import_smithy_client.expectInt32
+  });
+}, "de_ListHITsResponse");
+var de_ListQualificationRequestsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    NumResults: import_smithy_client.expectInt32,
+    QualificationRequests: (_) => de_QualificationRequestList(_, context)
+  });
+}, "de_ListQualificationRequestsResponse");
+var de_ListQualificationTypesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    NumResults: import_smithy_client.expectInt32,
+    QualificationTypes: (_) => de_QualificationTypeList(_, context)
+  });
+}, "de_ListQualificationTypesResponse");
+var de_ListReviewableHITsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    HITs: (_) => de_HITList(_, context),
+    NextToken: import_smithy_client.expectString,
+    NumResults: import_smithy_client.expectInt32
+  });
+}, "de_ListReviewableHITsResponse");
+var de_ListReviewPolicyResultsForHITResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AssignmentReviewPolicy: import_smithy_client._json,
+    AssignmentReviewReport: (_) => de_ReviewReport(_, context),
+    HITId: import_smithy_client.expectString,
+    HITReviewPolicy: import_smithy_client._json,
+    HITReviewReport: (_) => de_ReviewReport(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_ListReviewPolicyResultsForHITResponse");
+var de_ListWorkersWithQualificationTypeResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    NumResults: import_smithy_client.expectInt32,
+    Qualifications: (_) => de_QualificationList(_, context)
+  });
+}, "de_ListWorkersWithQualificationTypeResponse");
+var de_Qualification = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    GrantTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    IntegerValue: import_smithy_client.expectInt32,
+    LocaleValue: import_smithy_client._json,
+    QualificationTypeId: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    WorkerId: import_smithy_client.expectString
+  });
+}, "de_Qualification");
+var de_QualificationList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Qualification(entry, context);
+  });
+  return retVal;
+}, "de_QualificationList");
+var de_QualificationRequest = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Answer: import_smithy_client.expectString,
+    QualificationRequestId: import_smithy_client.expectString,
+    QualificationTypeId: import_smithy_client.expectString,
+    SubmitTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Test: import_smithy_client.expectString,
+    WorkerId: import_smithy_client.expectString
+  });
+}, "de_QualificationRequest");
+var de_QualificationRequestList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_QualificationRequest(entry, context);
+  });
+  return retVal;
+}, "de_QualificationRequestList");
+var de_QualificationType = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnswerKey: import_smithy_client.expectString,
+    AutoGranted: import_smithy_client.expectBoolean,
+    AutoGrantedValue: import_smithy_client.expectInt32,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Description: import_smithy_client.expectString,
+    IsRequestable: import_smithy_client.expectBoolean,
+    Keywords: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    QualificationTypeId: import_smithy_client.expectString,
+    QualificationTypeStatus: import_smithy_client.expectString,
+    RetryDelayInSeconds: import_smithy_client.expectLong,
+    Test: import_smithy_client.expectString,
+    TestDurationInSeconds: import_smithy_client.expectLong
+  });
+}, "de_QualificationType");
+var de_QualificationTypeList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_QualificationType(entry, context);
+  });
+  return retVal;
+}, "de_QualificationTypeList");
+var de_ReviewActionDetail = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ActionId: import_smithy_client.expectString,
+    ActionName: import_smithy_client.expectString,
+    CompleteTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ErrorCode: import_smithy_client.expectString,
+    Result: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    TargetId: import_smithy_client.expectString,
+    TargetType: import_smithy_client.expectString
+  });
+}, "de_ReviewActionDetail");
+var de_ReviewActionDetailList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ReviewActionDetail(entry, context);
+  });
+  return retVal;
+}, "de_ReviewActionDetailList");
+var de_ReviewReport = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ReviewActions: (_) => de_ReviewActionDetailList(_, context),
+    ReviewResults: import_smithy_client._json
+  });
+}, "de_ReviewReport");
+var de_UpdateQualificationTypeResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    QualificationType: (_) => de_QualificationType(_, context)
+  });
+}, "de_UpdateQualificationTypeResponse");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(MTurkServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `MTurkRequesterServiceV20170117.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/AcceptQualificationRequestCommand.ts
+var _AcceptQualificationRequestCommand = class _AcceptQualificationRequestCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "AcceptQualificationRequest", {}).n("MTurkClient", "AcceptQualificationRequestCommand").f(void 0, void 0).ser(se_AcceptQualificationRequestCommand).de(de_AcceptQualificationRequestCommand).build() {
+};
+__name(_AcceptQualificationRequestCommand, "AcceptQualificationRequestCommand");
+var AcceptQualificationRequestCommand = _AcceptQualificationRequestCommand;
+
+// src/commands/ApproveAssignmentCommand.ts
+
+
+
+
+var _ApproveAssignmentCommand = class _ApproveAssignmentCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ApproveAssignment", {}).n("MTurkClient", "ApproveAssignmentCommand").f(void 0, void 0).ser(se_ApproveAssignmentCommand).de(de_ApproveAssignmentCommand).build() {
+};
+__name(_ApproveAssignmentCommand, "ApproveAssignmentCommand");
+var ApproveAssignmentCommand = _ApproveAssignmentCommand;
+
+// src/commands/AssociateQualificationWithWorkerCommand.ts
+
+
+
+
+var _AssociateQualificationWithWorkerCommand = class _AssociateQualificationWithWorkerCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "AssociateQualificationWithWorker", {}).n("MTurkClient", "AssociateQualificationWithWorkerCommand").f(void 0, void 0).ser(se_AssociateQualificationWithWorkerCommand).de(de_AssociateQualificationWithWorkerCommand).build() {
+};
+__name(_AssociateQualificationWithWorkerCommand, "AssociateQualificationWithWorkerCommand");
+var AssociateQualificationWithWorkerCommand = _AssociateQualificationWithWorkerCommand;
+
+// src/commands/CreateAdditionalAssignmentsForHITCommand.ts
+
+
+
+
+var _CreateAdditionalAssignmentsForHITCommand = class _CreateAdditionalAssignmentsForHITCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "CreateAdditionalAssignmentsForHIT", {}).n("MTurkClient", "CreateAdditionalAssignmentsForHITCommand").f(void 0, void 0).ser(se_CreateAdditionalAssignmentsForHITCommand).de(de_CreateAdditionalAssignmentsForHITCommand).build() {
+};
+__name(_CreateAdditionalAssignmentsForHITCommand, "CreateAdditionalAssignmentsForHITCommand");
+var CreateAdditionalAssignmentsForHITCommand = _CreateAdditionalAssignmentsForHITCommand;
+
+// src/commands/CreateHITCommand.ts
+
+
+
+
+var _CreateHITCommand = class _CreateHITCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "CreateHIT", {}).n("MTurkClient", "CreateHITCommand").f(void 0, void 0).ser(se_CreateHITCommand).de(de_CreateHITCommand).build() {
+};
+__name(_CreateHITCommand, "CreateHITCommand");
+var CreateHITCommand = _CreateHITCommand;
+
+// src/commands/CreateHITTypeCommand.ts
+
+
+
+
+var _CreateHITTypeCommand = class _CreateHITTypeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "CreateHITType", {}).n("MTurkClient", "CreateHITTypeCommand").f(void 0, void 0).ser(se_CreateHITTypeCommand).de(de_CreateHITTypeCommand).build() {
+};
+__name(_CreateHITTypeCommand, "CreateHITTypeCommand");
+var CreateHITTypeCommand = _CreateHITTypeCommand;
+
+// src/commands/CreateHITWithHITTypeCommand.ts
+
+
+
+
+var _CreateHITWithHITTypeCommand = class _CreateHITWithHITTypeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "CreateHITWithHITType", {}).n("MTurkClient", "CreateHITWithHITTypeCommand").f(void 0, void 0).ser(se_CreateHITWithHITTypeCommand).de(de_CreateHITWithHITTypeCommand).build() {
+};
+__name(_CreateHITWithHITTypeCommand, "CreateHITWithHITTypeCommand");
+var CreateHITWithHITTypeCommand = _CreateHITWithHITTypeCommand;
+
+// src/commands/CreateQualificationTypeCommand.ts
+
+
+
+
+var _CreateQualificationTypeCommand = class _CreateQualificationTypeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "CreateQualificationType", {}).n("MTurkClient", "CreateQualificationTypeCommand").f(void 0, void 0).ser(se_CreateQualificationTypeCommand).de(de_CreateQualificationTypeCommand).build() {
+};
+__name(_CreateQualificationTypeCommand, "CreateQualificationTypeCommand");
+var CreateQualificationTypeCommand = _CreateQualificationTypeCommand;
+
+// src/commands/CreateWorkerBlockCommand.ts
+
+
+
+
+var _CreateWorkerBlockCommand = class _CreateWorkerBlockCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "CreateWorkerBlock", {}).n("MTurkClient", "CreateWorkerBlockCommand").f(void 0, void 0).ser(se_CreateWorkerBlockCommand).de(de_CreateWorkerBlockCommand).build() {
+};
+__name(_CreateWorkerBlockCommand, "CreateWorkerBlockCommand");
+var CreateWorkerBlockCommand = _CreateWorkerBlockCommand;
+
+// src/commands/DeleteHITCommand.ts
+
+
+
+
+var _DeleteHITCommand = class _DeleteHITCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "DeleteHIT", {}).n("MTurkClient", "DeleteHITCommand").f(void 0, void 0).ser(se_DeleteHITCommand).de(de_DeleteHITCommand).build() {
+};
+__name(_DeleteHITCommand, "DeleteHITCommand");
+var DeleteHITCommand = _DeleteHITCommand;
+
+// src/commands/DeleteQualificationTypeCommand.ts
+
+
+
+
+var _DeleteQualificationTypeCommand = class _DeleteQualificationTypeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "DeleteQualificationType", {}).n("MTurkClient", "DeleteQualificationTypeCommand").f(void 0, void 0).ser(se_DeleteQualificationTypeCommand).de(de_DeleteQualificationTypeCommand).build() {
+};
+__name(_DeleteQualificationTypeCommand, "DeleteQualificationTypeCommand");
+var DeleteQualificationTypeCommand = _DeleteQualificationTypeCommand;
+
+// src/commands/DeleteWorkerBlockCommand.ts
+
+
+
+
+var _DeleteWorkerBlockCommand = class _DeleteWorkerBlockCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "DeleteWorkerBlock", {}).n("MTurkClient", "DeleteWorkerBlockCommand").f(void 0, void 0).ser(se_DeleteWorkerBlockCommand).de(de_DeleteWorkerBlockCommand).build() {
+};
+__name(_DeleteWorkerBlockCommand, "DeleteWorkerBlockCommand");
+var DeleteWorkerBlockCommand = _DeleteWorkerBlockCommand;
+
+// src/commands/DisassociateQualificationFromWorkerCommand.ts
+
+
+
+
+var _DisassociateQualificationFromWorkerCommand = class _DisassociateQualificationFromWorkerCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "DisassociateQualificationFromWorker", {}).n("MTurkClient", "DisassociateQualificationFromWorkerCommand").f(void 0, void 0).ser(se_DisassociateQualificationFromWorkerCommand).de(de_DisassociateQualificationFromWorkerCommand).build() {
+};
+__name(_DisassociateQualificationFromWorkerCommand, "DisassociateQualificationFromWorkerCommand");
+var DisassociateQualificationFromWorkerCommand = _DisassociateQualificationFromWorkerCommand;
+
+// src/commands/GetAccountBalanceCommand.ts
+
+
+
+
+var _GetAccountBalanceCommand = class _GetAccountBalanceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "GetAccountBalance", {}).n("MTurkClient", "GetAccountBalanceCommand").f(void 0, void 0).ser(se_GetAccountBalanceCommand).de(de_GetAccountBalanceCommand).build() {
+};
+__name(_GetAccountBalanceCommand, "GetAccountBalanceCommand");
+var GetAccountBalanceCommand = _GetAccountBalanceCommand;
+
+// src/commands/GetAssignmentCommand.ts
+
+
+
+
+var _GetAssignmentCommand = class _GetAssignmentCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "GetAssignment", {}).n("MTurkClient", "GetAssignmentCommand").f(void 0, void 0).ser(se_GetAssignmentCommand).de(de_GetAssignmentCommand).build() {
+};
+__name(_GetAssignmentCommand, "GetAssignmentCommand");
+var GetAssignmentCommand = _GetAssignmentCommand;
+
+// src/commands/GetFileUploadURLCommand.ts
+
+
+
+
+var _GetFileUploadURLCommand = class _GetFileUploadURLCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "GetFileUploadURL", {}).n("MTurkClient", "GetFileUploadURLCommand").f(void 0, void 0).ser(se_GetFileUploadURLCommand).de(de_GetFileUploadURLCommand).build() {
+};
+__name(_GetFileUploadURLCommand, "GetFileUploadURLCommand");
+var GetFileUploadURLCommand = _GetFileUploadURLCommand;
+
+// src/commands/GetHITCommand.ts
+
+
+
+
+var _GetHITCommand = class _GetHITCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "GetHIT", {}).n("MTurkClient", "GetHITCommand").f(void 0, void 0).ser(se_GetHITCommand).de(de_GetHITCommand).build() {
+};
+__name(_GetHITCommand, "GetHITCommand");
+var GetHITCommand = _GetHITCommand;
+
+// src/commands/GetQualificationScoreCommand.ts
+
+
+
+
+var _GetQualificationScoreCommand = class _GetQualificationScoreCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "GetQualificationScore", {}).n("MTurkClient", "GetQualificationScoreCommand").f(void 0, void 0).ser(se_GetQualificationScoreCommand).de(de_GetQualificationScoreCommand).build() {
+};
+__name(_GetQualificationScoreCommand, "GetQualificationScoreCommand");
+var GetQualificationScoreCommand = _GetQualificationScoreCommand;
+
+// src/commands/GetQualificationTypeCommand.ts
+
+
+
+
+var _GetQualificationTypeCommand = class _GetQualificationTypeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "GetQualificationType", {}).n("MTurkClient", "GetQualificationTypeCommand").f(void 0, void 0).ser(se_GetQualificationTypeCommand).de(de_GetQualificationTypeCommand).build() {
+};
+__name(_GetQualificationTypeCommand, "GetQualificationTypeCommand");
+var GetQualificationTypeCommand = _GetQualificationTypeCommand;
+
+// src/commands/ListAssignmentsForHITCommand.ts
+
+
+
+
+var _ListAssignmentsForHITCommand = class _ListAssignmentsForHITCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ListAssignmentsForHIT", {}).n("MTurkClient", "ListAssignmentsForHITCommand").f(void 0, void 0).ser(se_ListAssignmentsForHITCommand).de(de_ListAssignmentsForHITCommand).build() {
+};
+__name(_ListAssignmentsForHITCommand, "ListAssignmentsForHITCommand");
+var ListAssignmentsForHITCommand = _ListAssignmentsForHITCommand;
+
+// src/commands/ListBonusPaymentsCommand.ts
+
+
+
+
+var _ListBonusPaymentsCommand = class _ListBonusPaymentsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ListBonusPayments", {}).n("MTurkClient", "ListBonusPaymentsCommand").f(void 0, void 0).ser(se_ListBonusPaymentsCommand).de(de_ListBonusPaymentsCommand).build() {
+};
+__name(_ListBonusPaymentsCommand, "ListBonusPaymentsCommand");
+var ListBonusPaymentsCommand = _ListBonusPaymentsCommand;
+
+// src/commands/ListHITsCommand.ts
+
+
+
+
+var _ListHITsCommand = class _ListHITsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ListHITs", {}).n("MTurkClient", "ListHITsCommand").f(void 0, void 0).ser(se_ListHITsCommand).de(de_ListHITsCommand).build() {
+};
+__name(_ListHITsCommand, "ListHITsCommand");
+var ListHITsCommand = _ListHITsCommand;
+
+// src/commands/ListHITsForQualificationTypeCommand.ts
+
+
+
+
+var _ListHITsForQualificationTypeCommand = class _ListHITsForQualificationTypeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ListHITsForQualificationType", {}).n("MTurkClient", "ListHITsForQualificationTypeCommand").f(void 0, void 0).ser(se_ListHITsForQualificationTypeCommand).de(de_ListHITsForQualificationTypeCommand).build() {
+};
+__name(_ListHITsForQualificationTypeCommand, "ListHITsForQualificationTypeCommand");
+var ListHITsForQualificationTypeCommand = _ListHITsForQualificationTypeCommand;
+
+// src/commands/ListQualificationRequestsCommand.ts
+
+
+
+
+var _ListQualificationRequestsCommand = class _ListQualificationRequestsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ListQualificationRequests", {}).n("MTurkClient", "ListQualificationRequestsCommand").f(void 0, void 0).ser(se_ListQualificationRequestsCommand).de(de_ListQualificationRequestsCommand).build() {
+};
+__name(_ListQualificationRequestsCommand, "ListQualificationRequestsCommand");
+var ListQualificationRequestsCommand = _ListQualificationRequestsCommand;
+
+// src/commands/ListQualificationTypesCommand.ts
+
+
+
+
+var _ListQualificationTypesCommand = class _ListQualificationTypesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ListQualificationTypes", {}).n("MTurkClient", "ListQualificationTypesCommand").f(void 0, void 0).ser(se_ListQualificationTypesCommand).de(de_ListQualificationTypesCommand).build() {
+};
+__name(_ListQualificationTypesCommand, "ListQualificationTypesCommand");
+var ListQualificationTypesCommand = _ListQualificationTypesCommand;
+
+// src/commands/ListReviewableHITsCommand.ts
+
+
+
+
+var _ListReviewableHITsCommand = class _ListReviewableHITsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ListReviewableHITs", {}).n("MTurkClient", "ListReviewableHITsCommand").f(void 0, void 0).ser(se_ListReviewableHITsCommand).de(de_ListReviewableHITsCommand).build() {
+};
+__name(_ListReviewableHITsCommand, "ListReviewableHITsCommand");
+var ListReviewableHITsCommand = _ListReviewableHITsCommand;
+
+// src/commands/ListReviewPolicyResultsForHITCommand.ts
+
+
+
+
+var _ListReviewPolicyResultsForHITCommand = class _ListReviewPolicyResultsForHITCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ListReviewPolicyResultsForHIT", {}).n("MTurkClient", "ListReviewPolicyResultsForHITCommand").f(void 0, void 0).ser(se_ListReviewPolicyResultsForHITCommand).de(de_ListReviewPolicyResultsForHITCommand).build() {
+};
+__name(_ListReviewPolicyResultsForHITCommand, "ListReviewPolicyResultsForHITCommand");
+var ListReviewPolicyResultsForHITCommand = _ListReviewPolicyResultsForHITCommand;
+
+// src/commands/ListWorkerBlocksCommand.ts
+
+
+
+
+var _ListWorkerBlocksCommand = class _ListWorkerBlocksCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ListWorkerBlocks", {}).n("MTurkClient", "ListWorkerBlocksCommand").f(void 0, void 0).ser(se_ListWorkerBlocksCommand).de(de_ListWorkerBlocksCommand).build() {
+};
+__name(_ListWorkerBlocksCommand, "ListWorkerBlocksCommand");
+var ListWorkerBlocksCommand = _ListWorkerBlocksCommand;
+
+// src/commands/ListWorkersWithQualificationTypeCommand.ts
+
+
+
+
+var _ListWorkersWithQualificationTypeCommand = class _ListWorkersWithQualificationTypeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "ListWorkersWithQualificationType", {}).n("MTurkClient", "ListWorkersWithQualificationTypeCommand").f(void 0, void 0).ser(se_ListWorkersWithQualificationTypeCommand).de(de_ListWorkersWithQualificationTypeCommand).build() {
+};
+__name(_ListWorkersWithQualificationTypeCommand, "ListWorkersWithQualificationTypeCommand");
+var ListWorkersWithQualificationTypeCommand = _ListWorkersWithQualificationTypeCommand;
+
+// src/commands/NotifyWorkersCommand.ts
+
+
+
+
+var _NotifyWorkersCommand = class _NotifyWorkersCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "NotifyWorkers", {}).n("MTurkClient", "NotifyWorkersCommand").f(void 0, void 0).ser(se_NotifyWorkersCommand).de(de_NotifyWorkersCommand).build() {
+};
+__name(_NotifyWorkersCommand, "NotifyWorkersCommand");
+var NotifyWorkersCommand = _NotifyWorkersCommand;
+
+// src/commands/RejectAssignmentCommand.ts
+
+
+
+
+var _RejectAssignmentCommand = class _RejectAssignmentCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "RejectAssignment", {}).n("MTurkClient", "RejectAssignmentCommand").f(void 0, void 0).ser(se_RejectAssignmentCommand).de(de_RejectAssignmentCommand).build() {
+};
+__name(_RejectAssignmentCommand, "RejectAssignmentCommand");
+var RejectAssignmentCommand = _RejectAssignmentCommand;
+
+// src/commands/RejectQualificationRequestCommand.ts
+
+
+
+
+var _RejectQualificationRequestCommand = class _RejectQualificationRequestCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "RejectQualificationRequest", {}).n("MTurkClient", "RejectQualificationRequestCommand").f(void 0, void 0).ser(se_RejectQualificationRequestCommand).de(de_RejectQualificationRequestCommand).build() {
+};
+__name(_RejectQualificationRequestCommand, "RejectQualificationRequestCommand");
+var RejectQualificationRequestCommand = _RejectQualificationRequestCommand;
+
+// src/commands/SendBonusCommand.ts
+
+
+
+
+var _SendBonusCommand = class _SendBonusCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "SendBonus", {}).n("MTurkClient", "SendBonusCommand").f(void 0, void 0).ser(se_SendBonusCommand).de(de_SendBonusCommand).build() {
+};
+__name(_SendBonusCommand, "SendBonusCommand");
+var SendBonusCommand = _SendBonusCommand;
+
+// src/commands/SendTestEventNotificationCommand.ts
+
+
+
+
+var _SendTestEventNotificationCommand = class _SendTestEventNotificationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "SendTestEventNotification", {}).n("MTurkClient", "SendTestEventNotificationCommand").f(void 0, void 0).ser(se_SendTestEventNotificationCommand).de(de_SendTestEventNotificationCommand).build() {
+};
+__name(_SendTestEventNotificationCommand, "SendTestEventNotificationCommand");
+var SendTestEventNotificationCommand = _SendTestEventNotificationCommand;
+
+// src/commands/UpdateExpirationForHITCommand.ts
+
+
+
+
+var _UpdateExpirationForHITCommand = class _UpdateExpirationForHITCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "UpdateExpirationForHIT", {}).n("MTurkClient", "UpdateExpirationForHITCommand").f(void 0, void 0).ser(se_UpdateExpirationForHITCommand).de(de_UpdateExpirationForHITCommand).build() {
+};
+__name(_UpdateExpirationForHITCommand, "UpdateExpirationForHITCommand");
+var UpdateExpirationForHITCommand = _UpdateExpirationForHITCommand;
+
+// src/commands/UpdateHITReviewStatusCommand.ts
+
+
+
+
+var _UpdateHITReviewStatusCommand = class _UpdateHITReviewStatusCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "UpdateHITReviewStatus", {}).n("MTurkClient", "UpdateHITReviewStatusCommand").f(void 0, void 0).ser(se_UpdateHITReviewStatusCommand).de(de_UpdateHITReviewStatusCommand).build() {
+};
+__name(_UpdateHITReviewStatusCommand, "UpdateHITReviewStatusCommand");
+var UpdateHITReviewStatusCommand = _UpdateHITReviewStatusCommand;
+
+// src/commands/UpdateHITTypeOfHITCommand.ts
+
+
+
+
+var _UpdateHITTypeOfHITCommand = class _UpdateHITTypeOfHITCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "UpdateHITTypeOfHIT", {}).n("MTurkClient", "UpdateHITTypeOfHITCommand").f(void 0, void 0).ser(se_UpdateHITTypeOfHITCommand).de(de_UpdateHITTypeOfHITCommand).build() {
+};
+__name(_UpdateHITTypeOfHITCommand, "UpdateHITTypeOfHITCommand");
+var UpdateHITTypeOfHITCommand = _UpdateHITTypeOfHITCommand;
+
+// src/commands/UpdateNotificationSettingsCommand.ts
+
+
+
+
+var _UpdateNotificationSettingsCommand = class _UpdateNotificationSettingsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "UpdateNotificationSettings", {}).n("MTurkClient", "UpdateNotificationSettingsCommand").f(void 0, void 0).ser(se_UpdateNotificationSettingsCommand).de(de_UpdateNotificationSettingsCommand).build() {
+};
+__name(_UpdateNotificationSettingsCommand, "UpdateNotificationSettingsCommand");
+var UpdateNotificationSettingsCommand = _UpdateNotificationSettingsCommand;
+
+// src/commands/UpdateQualificationTypeCommand.ts
+
+
+
+
+var _UpdateQualificationTypeCommand = class _UpdateQualificationTypeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("MTurkRequesterServiceV20170117", "UpdateQualificationType", {}).n("MTurkClient", "UpdateQualificationTypeCommand").f(void 0, void 0).ser(se_UpdateQualificationTypeCommand).de(de_UpdateQualificationTypeCommand).build() {
+};
+__name(_UpdateQualificationTypeCommand, "UpdateQualificationTypeCommand");
+var UpdateQualificationTypeCommand = _UpdateQualificationTypeCommand;
+
+// src/MTurk.ts
+var commands = {
+  AcceptQualificationRequestCommand,
+  ApproveAssignmentCommand,
+  AssociateQualificationWithWorkerCommand,
+  CreateAdditionalAssignmentsForHITCommand,
+  CreateHITCommand,
+  CreateHITTypeCommand,
+  CreateHITWithHITTypeCommand,
+  CreateQualificationTypeCommand,
+  CreateWorkerBlockCommand,
+  DeleteHITCommand,
+  DeleteQualificationTypeCommand,
+  DeleteWorkerBlockCommand,
+  DisassociateQualificationFromWorkerCommand,
+  GetAccountBalanceCommand,
+  GetAssignmentCommand,
+  GetFileUploadURLCommand,
+  GetHITCommand,
+  GetQualificationScoreCommand,
+  GetQualificationTypeCommand,
+  ListAssignmentsForHITCommand,
+  ListBonusPaymentsCommand,
+  ListHITsCommand,
+  ListHITsForQualificationTypeCommand,
+  ListQualificationRequestsCommand,
+  ListQualificationTypesCommand,
+  ListReviewableHITsCommand,
+  ListReviewPolicyResultsForHITCommand,
+  ListWorkerBlocksCommand,
+  ListWorkersWithQualificationTypeCommand,
+  NotifyWorkersCommand,
+  RejectAssignmentCommand,
+  RejectQualificationRequestCommand,
+  SendBonusCommand,
+  SendTestEventNotificationCommand,
+  UpdateExpirationForHITCommand,
+  UpdateHITReviewStatusCommand,
+  UpdateHITTypeOfHITCommand,
+  UpdateNotificationSettingsCommand,
+  UpdateQualificationTypeCommand
+};
+var _MTurk = class _MTurk extends MTurkClient {
+};
+__name(_MTurk, "MTurk");
+var MTurk = _MTurk;
+(0, import_smithy_client.createAggregatedClient)(commands, MTurk);
+
+// src/pagination/ListAssignmentsForHITPaginator.ts
+var import_core = require("@smithy/core");
+var paginateListAssignmentsForHIT = (0, import_core.createPaginator)(MTurkClient, ListAssignmentsForHITCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListBonusPaymentsPaginator.ts
+
+var paginateListBonusPayments = (0, import_core.createPaginator)(MTurkClient, ListBonusPaymentsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListHITsForQualificationTypePaginator.ts
+
+var paginateListHITsForQualificationType = (0, import_core.createPaginator)(MTurkClient, ListHITsForQualificationTypeCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListHITsPaginator.ts
+
+var paginateListHITs = (0, import_core.createPaginator)(MTurkClient, ListHITsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListQualificationRequestsPaginator.ts
+
+var paginateListQualificationRequests = (0, import_core.createPaginator)(MTurkClient, ListQualificationRequestsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListQualificationTypesPaginator.ts
+
+var paginateListQualificationTypes = (0, import_core.createPaginator)(MTurkClient, ListQualificationTypesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListReviewPolicyResultsForHITPaginator.ts
+
+var paginateListReviewPolicyResultsForHIT = (0, import_core.createPaginator)(MTurkClient, ListReviewPolicyResultsForHITCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListReviewableHITsPaginator.ts
+
+var paginateListReviewableHITs = (0, import_core.createPaginator)(MTurkClient, ListReviewableHITsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListWorkerBlocksPaginator.ts
+
+var paginateListWorkerBlocks = (0, import_core.createPaginator)(MTurkClient, ListWorkerBlocksCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListWorkersWithQualificationTypePaginator.ts
+
+var paginateListWorkersWithQualificationType = (0, import_core.createPaginator)(MTurkClient, ListWorkersWithQualificationTypeCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AcceptQualificationRequestCommand,
+  ApproveAssignmentCommand,
+  AssignmentStatus,
+  AssociateQualificationWithWorkerCommand,
+  Comparator,
+  CreateAdditionalAssignmentsForHITCommand,
+  CreateHITCommand,
+  CreateHITTypeCommand,
+  CreateHITWithHITTypeCommand,
+  CreateQualificationTypeCommand,
+  CreateWorkerBlockCommand,
+  DeleteHITCommand,
+  DeleteQualificationTypeCommand,
+  DeleteWorkerBlockCommand,
+  DisassociateQualificationFromWorkerCommand,
+  EventType,
+  GetAccountBalanceCommand,
+  GetAssignmentCommand,
+  GetFileUploadURLCommand,
+  GetHITCommand,
+  GetQualificationScoreCommand,
+  GetQualificationTypeCommand,
+  HITAccessActions,
+  HITReviewStatus,
+  HITStatus,
+  ListAssignmentsForHITCommand,
+  ListBonusPaymentsCommand,
+  ListHITsCommand,
+  ListHITsForQualificationTypeCommand,
+  ListQualificationRequestsCommand,
+  ListQualificationTypesCommand,
+  ListReviewPolicyResultsForHITCommand,
+  ListReviewableHITsCommand,
+  ListWorkerBlocksCommand,
+  ListWorkersWithQualificationTypeCommand,
+  MTurk,
+  MTurkClient,
+  MTurkServiceException,
+  NotificationTransport,
+  NotifyWorkersCommand,
+  NotifyWorkersFailureCode,
+  QualificationStatus,
+  QualificationTypeStatus,
+  RejectAssignmentCommand,
+  RejectQualificationRequestCommand,
+  RequestError,
+  ReviewActionStatus,
+  ReviewPolicyLevel,
+  ReviewableHITStatus,
+  SendBonusCommand,
+  SendTestEventNotificationCommand,
+  ServiceFault,
+  UpdateExpirationForHITCommand,
+  UpdateHITReviewStatusCommand,
+  UpdateHITTypeOfHITCommand,
+  UpdateNotificationSettingsCommand,
+  UpdateQualificationTypeCommand,
+  __Client,
+  paginateListAssignmentsForHIT,
+  paginateListBonusPayments,
+  paginateListHITs,
+  paginateListHITsForQualificationType,
+  paginateListQualificationRequests,
+  paginateListQualificationTypes,
+  paginateListReviewPolicyResultsForHIT,
+  paginateListReviewableHITs,
+  paginateListWorkerBlocks,
+  paginateListWorkersWithQualificationType
+});