npm - @aws-sdk/client-mturk - Versions diffs - 3.901.0 → 3.906.0 - Mend

@aws-sdk/client-mturk 3.901.0 → 3.906.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist-cjs/index.js +2023 -2112
package/package.json +5 -5

package/dist-cjs/index.js CHANGED Viewed

@@ -1,2208 +1,2119 @@
-"use strict";
-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 index_exports = {};
-__export(index_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(index_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_user_agent = require("@aws-sdk/middleware-user-agent");
-var import_config_resolver = require("@smithy/config-resolver");
-var import_core = require("@smithy/core");
-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");
-var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
-// src/endpoint/EndpointParameters.ts
-var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
-  return Object.assign(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" }
+'use strict';
+var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
+var middlewareLogger = require('@aws-sdk/middleware-logger');
+var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
+var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
+var configResolver = require('@smithy/config-resolver');
+var core = require('@smithy/core');
+var middlewareContentLength = require('@smithy/middleware-content-length');
+var middlewareEndpoint = require('@smithy/middleware-endpoint');
+var middlewareRetry = require('@smithy/middleware-retry');
+var smithyClient = require('@smithy/smithy-client');
+var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
+var runtimeConfig = require('./runtimeConfig');
+var regionConfigResolver = require('@aws-sdk/region-config-resolver');
+var protocolHttp = require('@smithy/protocol-http');
+var middlewareSerde = require('@smithy/middleware-serde');
+var core$1 = require('@aws-sdk/core');
+const resolveClientEndpointParameters = (options) => {
+    return Object.assign(options, {
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "mturk-requester",
+    });
+};
+const 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");
+const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _credentials = runtimeConfig.credentials;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setCredentials(credentials) {
+            _credentials = credentials;
+        },
+        credentials() {
+            return _credentials;
+        },
+    };
+};
+const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        credentials: config.credentials(),
+    };
+};
-// 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");
+const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+};
-// src/auth/httpAuthExtensionConfiguration.ts
-var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
-  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
-  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
-  let _credentials = runtimeConfig.credentials;
-  return {
-    setHttpAuthScheme(httpAuthScheme) {
-      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
-      if (index === -1) {
-        _httpAuthSchemes.push(httpAuthScheme);
-      } else {
-        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
-      }
-    },
-    httpAuthSchemes() {
-      return _httpAuthSchemes;
-    },
-    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
-      _httpAuthSchemeProvider = httpAuthSchemeProvider;
-    },
-    httpAuthSchemeProvider() {
-      return _httpAuthSchemeProvider;
-    },
-    setCredentials(credentials) {
-      _credentials = credentials;
-    },
-    credentials() {
-      return _credentials;
+class MTurkClient extends smithyClient.Client {
+    config;
+    constructor(...[configuration]) {
+        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        super(_config_0);
+        this.initConfig = _config_0;
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
+        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
+        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
+        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+        this.config = _config_8;
+        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
+        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
+        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultMTurkHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
     }
-  };
-}, "getHttpAuthExtensionConfiguration");
-var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
-  return {
-    httpAuthSchemes: config.httpAuthSchemes(),
-    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
-    credentials: config.credentials()
-  };
-}, "resolveHttpAuthRuntimeConfig");
+}
-// src/runtimeExtensions.ts
-var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
-  const extensionConfiguration = Object.assign(
-    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
-    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
-    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
-    getHttpAuthExtensionConfiguration(runtimeConfig)
-  );
-  extensions.forEach((extension) => extension.configure(extensionConfiguration));
-  return Object.assign(
-    runtimeConfig,
-    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
-    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
-    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
-    resolveHttpAuthRuntimeConfig(extensionConfiguration)
-  );
-}, "resolveRuntimeExtensions");
+class MTurkServiceException extends smithyClient.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, MTurkServiceException.prototype);
+    }
+}
-// src/MTurkClient.ts
-var MTurkClient = class extends import_smithy_client.Client {
-  static {
-    __name(this, "MTurkClient");
-  }
-  /**
-   * The resolved configuration of MTurkClient class. This is resolved and normalized from the {@link MTurkClientConfig | constructor configuration interface}.
-   */
-  config;
-  constructor(...[configuration]) {
-    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
-    super(_config_0);
-    this.initConfig = _config_0;
-    const _config_1 = resolveClientEndpointParameters(_config_0);
-    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
-    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
-    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
-    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
-    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
-    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
-    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
-    this.config = _config_8;
-    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
-    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_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
-        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultMTurkHttpAuthSchemeParametersProvider,
-        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
-          "aws.auth#sigv4": config.credentials
-        }), "identityProviderConfigProvider")
-      })
-    );
-    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(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();
-  }
+class RequestError extends MTurkServiceException {
+    name = "RequestError";
+    $fault = "client";
+    Message;
+    TurkErrorCode;
+    constructor(opts) {
+        super({
+            name: "RequestError",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RequestError.prototype);
+        this.Message = opts.Message;
+        this.TurkErrorCode = opts.TurkErrorCode;
+    }
+}
+class ServiceFault extends MTurkServiceException {
+    name = "ServiceFault";
+    $fault = "server";
+    Message;
+    TurkErrorCode;
+    constructor(opts) {
+        super({
+            name: "ServiceFault",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceFault.prototype);
+        this.Message = opts.Message;
+        this.TurkErrorCode = opts.TurkErrorCode;
+    }
+}
+const AssignmentStatus = {
+    Approved: "Approved",
+    Rejected: "Rejected",
+    Submitted: "Submitted",
 };
-// src/MTurk.ts
-// src/commands/AcceptQualificationRequestCommand.ts
-var import_middleware_serde = require("@smithy/middleware-serde");
-// src/protocols/Aws_json1_1.ts
-var import_core2 = require("@aws-sdk/core");
-// src/models/MTurkServiceException.ts
-var MTurkServiceException = class _MTurkServiceException extends import_smithy_client.ServiceException {
-  static {
-    __name(this, "MTurkServiceException");
-  }
-  /**
-   * @internal
-   */
-  constructor(options) {
-    super(options);
-    Object.setPrototypeOf(this, _MTurkServiceException.prototype);
-  }
+const Comparator = {
+    DoesNotExist: "DoesNotExist",
+    EqualTo: "EqualTo",
+    Exists: "Exists",
+    GreaterThan: "GreaterThan",
+    GreaterThanOrEqualTo: "GreaterThanOrEqualTo",
+    In: "In",
+    LessThan: "LessThan",
+    LessThanOrEqualTo: "LessThanOrEqualTo",
+    NotEqualTo: "NotEqualTo",
+    NotIn: "NotIn",
+};
+const HITAccessActions = {
+    Accept: "Accept",
+    DiscoverPreviewAndAccept: "DiscoverPreviewAndAccept",
+    PreviewAndAccept: "PreviewAndAccept",
+};
+const HITReviewStatus = {
+    MarkedForReview: "MarkedForReview",
+    NotReviewed: "NotReviewed",
+    ReviewedAppropriate: "ReviewedAppropriate",
+    ReviewedInappropriate: "ReviewedInappropriate",
+};
+const HITStatus = {
+    Assignable: "Assignable",
+    Disposed: "Disposed",
+    Reviewable: "Reviewable",
+    Reviewing: "Reviewing",
+    Unassignable: "Unassignable",
+};
+const QualificationTypeStatus = {
+    Active: "Active",
+    Inactive: "Inactive",
+};
+const 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",
+};
+const QualificationStatus = {
+    Granted: "Granted",
+    Revoked: "Revoked",
+};
+const ReviewableHITStatus = {
+    Reviewable: "Reviewable",
+    Reviewing: "Reviewing",
+};
+const ReviewPolicyLevel = {
+    Assignment: "Assignment",
+    HIT: "HIT",
+};
+const ReviewActionStatus = {
+    Cancelled: "Cancelled",
+    Failed: "Failed",
+    Intended: "Intended",
+    Succeeded: "Succeeded",
+};
+const NotifyWorkersFailureCode = {
+    HardFailure: "HardFailure",
+    SoftFailure: "SoftFailure",
+};
+const NotificationTransport = {
+    Email: "Email",
+    SNS: "SNS",
+    SQS: "SQS",
 };
-// src/models/models_0.ts
-var RequestError = class _RequestError extends MTurkServiceException {
-  static {
-    __name(this, "RequestError");
-  }
-  name = "RequestError";
-  $fault = "client";
-  Message;
-  TurkErrorCode;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RequestError",
-      $fault: "client",
-      ...opts
+const se_AcceptQualificationRequestCommand = async (input, context) => {
+    const headers = sharedHeaders("AcceptQualificationRequest");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ApproveAssignmentCommand = async (input, context) => {
+    const headers = sharedHeaders("ApproveAssignment");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_AssociateQualificationWithWorkerCommand = async (input, context) => {
+    const headers = sharedHeaders("AssociateQualificationWithWorker");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreateAdditionalAssignmentsForHITCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateAdditionalAssignmentsForHIT");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreateHITCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateHIT");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreateHITTypeCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateHITType");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreateHITWithHITTypeCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateHITWithHITType");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreateQualificationTypeCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateQualificationType");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreateWorkerBlockCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateWorkerBlock");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DeleteHITCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteHIT");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DeleteQualificationTypeCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteQualificationType");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DeleteWorkerBlockCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteWorkerBlock");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DisassociateQualificationFromWorkerCommand = async (input, context) => {
+    const headers = sharedHeaders("DisassociateQualificationFromWorker");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetAccountBalanceCommand = async (input, context) => {
+    const headers = sharedHeaders("GetAccountBalance");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetAssignmentCommand = async (input, context) => {
+    const headers = sharedHeaders("GetAssignment");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetFileUploadURLCommand = async (input, context) => {
+    const headers = sharedHeaders("GetFileUploadURL");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetHITCommand = async (input, context) => {
+    const headers = sharedHeaders("GetHIT");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetQualificationScoreCommand = async (input, context) => {
+    const headers = sharedHeaders("GetQualificationScore");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetQualificationTypeCommand = async (input, context) => {
+    const headers = sharedHeaders("GetQualificationType");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListAssignmentsForHITCommand = async (input, context) => {
+    const headers = sharedHeaders("ListAssignmentsForHIT");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListBonusPaymentsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListBonusPayments");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListHITsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListHITs");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListHITsForQualificationTypeCommand = async (input, context) => {
+    const headers = sharedHeaders("ListHITsForQualificationType");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListQualificationRequestsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListQualificationRequests");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListQualificationTypesCommand = async (input, context) => {
+    const headers = sharedHeaders("ListQualificationTypes");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListReviewableHITsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListReviewableHITs");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListReviewPolicyResultsForHITCommand = async (input, context) => {
+    const headers = sharedHeaders("ListReviewPolicyResultsForHIT");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListWorkerBlocksCommand = async (input, context) => {
+    const headers = sharedHeaders("ListWorkerBlocks");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListWorkersWithQualificationTypeCommand = async (input, context) => {
+    const headers = sharedHeaders("ListWorkersWithQualificationType");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_NotifyWorkersCommand = async (input, context) => {
+    const headers = sharedHeaders("NotifyWorkers");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_RejectAssignmentCommand = async (input, context) => {
+    const headers = sharedHeaders("RejectAssignment");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_RejectQualificationRequestCommand = async (input, context) => {
+    const headers = sharedHeaders("RejectQualificationRequest");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_SendBonusCommand = async (input, context) => {
+    const headers = sharedHeaders("SendBonus");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_SendTestEventNotificationCommand = async (input, context) => {
+    const headers = sharedHeaders("SendTestEventNotification");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UpdateExpirationForHITCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateExpirationForHIT");
+    let body;
+    body = JSON.stringify(se_UpdateExpirationForHITRequest(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UpdateHITReviewStatusCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateHITReviewStatus");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UpdateHITTypeOfHITCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateHITTypeOfHIT");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UpdateNotificationSettingsCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateNotificationSettings");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UpdateQualificationTypeCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateQualificationType");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const de_AcceptQualificationRequestCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ApproveAssignmentCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_AssociateQualificationWithWorkerCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateAdditionalAssignmentsForHITCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateHITCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_CreateHITResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateHITTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateHITWithHITTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_CreateHITWithHITTypeResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateQualificationTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_CreateQualificationTypeResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateWorkerBlockCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DeleteHITCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DeleteQualificationTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DeleteWorkerBlockCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DisassociateQualificationFromWorkerCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetAccountBalanceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetAssignmentCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_GetAssignmentResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetFileUploadURLCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetHITCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_GetHITResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetQualificationScoreCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_GetQualificationScoreResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetQualificationTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_GetQualificationTypeResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListAssignmentsForHITCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListAssignmentsForHITResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListBonusPaymentsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListBonusPaymentsResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListHITsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListHITsResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListHITsForQualificationTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListHITsForQualificationTypeResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListQualificationRequestsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListQualificationRequestsResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListQualificationTypesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListQualificationTypesResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListReviewableHITsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListReviewableHITsResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListReviewPolicyResultsForHITCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListReviewPolicyResultsForHITResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListWorkerBlocksCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListWorkersWithQualificationTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_ListWorkersWithQualificationTypeResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_NotifyWorkersCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_RejectAssignmentCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_RejectQualificationRequestCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_SendBonusCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_SendTestEventNotificationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UpdateExpirationForHITCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UpdateHITReviewStatusCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UpdateHITTypeOfHITCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UpdateNotificationSettingsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UpdateQualificationTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_UpdateQualificationTypeResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await core$1.parseJsonErrorBody(output.body, context),
+    };
+    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "RequestError":
+        case "com.amazonaws.mturk#RequestError":
+            throw await de_RequestErrorRes(parsedOutput);
+        case "ServiceFault":
+        case "com.amazonaws.mturk#ServiceFault":
+            throw await de_ServiceFaultRes(parsedOutput);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+const de_RequestErrorRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new RequestError({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _RequestError.prototype);
-    this.Message = opts.Message;
-    this.TurkErrorCode = opts.TurkErrorCode;
-  }
-};
-var ServiceFault = class _ServiceFault extends MTurkServiceException {
-  static {
-    __name(this, "ServiceFault");
-  }
-  name = "ServiceFault";
-  $fault = "server";
-  Message;
-  TurkErrorCode;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ServiceFault",
-      $fault: "server",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ServiceFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ServiceFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ServiceFault.prototype);
-    this.Message = opts.Message;
-    this.TurkErrorCode = opts.TurkErrorCode;
-  }
-};
-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"
+    return smithyClient.decorateServiceException(exception, body);
 };
-// 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_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_AcceptQualificationRequestCommand");
-var de_ApproveAssignmentCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ApproveAssignmentCommand");
-var de_AssociateQualificationWithWorkerCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_AssociateQualificationWithWorkerCommand");
-var de_CreateAdditionalAssignmentsForHITCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateAdditionalAssignmentsForHITCommand");
-var de_CreateHITCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_CreateHITResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateHITCommand");
-var de_CreateHITTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateHITTypeCommand");
-var de_CreateHITWithHITTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_CreateHITWithHITTypeResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateHITWithHITTypeCommand");
-var de_CreateQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_CreateQualificationTypeResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateQualificationTypeCommand");
-var de_CreateWorkerBlockCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateWorkerBlockCommand");
-var de_DeleteHITCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DeleteHITCommand");
-var de_DeleteQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DeleteQualificationTypeCommand");
-var de_DeleteWorkerBlockCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DeleteWorkerBlockCommand");
-var de_DisassociateQualificationFromWorkerCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DisassociateQualificationFromWorkerCommand");
-var de_GetAccountBalanceCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetAccountBalanceCommand");
-var de_GetAssignmentCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_GetAssignmentResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetAssignmentCommand");
-var de_GetFileUploadURLCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetFileUploadURLCommand");
-var de_GetHITCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_GetHITResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetHITCommand");
-var de_GetQualificationScoreCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_GetQualificationScoreResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetQualificationScoreCommand");
-var de_GetQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_GetQualificationTypeResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetQualificationTypeCommand");
-var de_ListAssignmentsForHITCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListAssignmentsForHITResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListAssignmentsForHITCommand");
-var de_ListBonusPaymentsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListBonusPaymentsResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListBonusPaymentsCommand");
-var de_ListHITsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListHITsResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListHITsCommand");
-var de_ListHITsForQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListHITsForQualificationTypeResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListHITsForQualificationTypeCommand");
-var de_ListQualificationRequestsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListQualificationRequestsResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListQualificationRequestsCommand");
-var de_ListQualificationTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListQualificationTypesResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListQualificationTypesCommand");
-var de_ListReviewableHITsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListReviewableHITsResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListReviewableHITsCommand");
-var de_ListReviewPolicyResultsForHITCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListReviewPolicyResultsForHITResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListReviewPolicyResultsForHITCommand");
-var de_ListWorkerBlocksCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListWorkerBlocksCommand");
-var de_ListWorkersWithQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ListWorkersWithQualificationTypeResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListWorkersWithQualificationTypeCommand");
-var de_NotifyWorkersCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_NotifyWorkersCommand");
-var de_RejectAssignmentCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_RejectAssignmentCommand");
-var de_RejectQualificationRequestCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_RejectQualificationRequestCommand");
-var de_SendBonusCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_SendBonusCommand");
-var de_SendTestEventNotificationCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_SendTestEventNotificationCommand");
-var de_UpdateExpirationForHITCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UpdateExpirationForHITCommand");
-var de_UpdateHITReviewStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UpdateHITReviewStatusCommand");
-var de_UpdateHITTypeOfHITCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UpdateHITTypeOfHITCommand");
-var de_UpdateNotificationSettingsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UpdateNotificationSettingsCommand");
-var de_UpdateQualificationTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_UpdateQualificationTypeResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UpdateQualificationTypeCommand");
-var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
-  const parsedOutput = {
-    ...output,
-    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
-  };
-  const errorCode = (0, import_core2.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_CommandError");
-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: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "ExpireAt"),
-    HITId: []
-  });
-}, "se_UpdateExpirationForHITRequest");
-var de_Assignment = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    AcceptTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "AcceptTime"),
-    Answer: import_smithy_client.expectString,
-    ApprovalTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "ApprovalTime"),
-    AssignmentId: import_smithy_client.expectString,
-    AssignmentStatus: import_smithy_client.expectString,
-    AutoApprovalTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "AutoApprovalTime"),
-    Deadline: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "Deadline"),
-    HITId: import_smithy_client.expectString,
-    RejectionTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "RejectionTime"),
-    RequesterFeedback: import_smithy_client.expectString,
-    SubmitTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "SubmitTime"),
-    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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "GrantTime"),
-    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: /* @__PURE__ */ __name((_) => de_HIT(_, context), "HIT")
-  });
-}, "de_CreateHITResponse");
-var de_CreateHITWithHITTypeResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    HIT: /* @__PURE__ */ __name((_) => de_HIT(_, context), "HIT")
-  });
-}, "de_CreateHITWithHITTypeResponse");
-var de_CreateQualificationTypeResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    QualificationType: /* @__PURE__ */ __name((_) => de_QualificationType(_, context), "QualificationType")
-  });
-}, "de_CreateQualificationTypeResponse");
-var de_GetAssignmentResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Assignment: /* @__PURE__ */ __name((_) => de_Assignment(_, context), "Assignment"),
-    HIT: /* @__PURE__ */ __name((_) => de_HIT(_, context), "HIT")
-  });
-}, "de_GetAssignmentResponse");
-var de_GetHITResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    HIT: /* @__PURE__ */ __name((_) => de_HIT(_, context), "HIT")
-  });
-}, "de_GetHITResponse");
-var de_GetQualificationScoreResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Qualification: /* @__PURE__ */ __name((_) => de_Qualification(_, context), "Qualification")
-  });
-}, "de_GetQualificationScoreResponse");
-var de_GetQualificationTypeResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    QualificationType: /* @__PURE__ */ __name((_) => de_QualificationType(_, context), "QualificationType")
-  });
-}, "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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreationTime"),
-    Description: import_smithy_client.expectString,
-    Expiration: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "Expiration"),
-    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: /* @__PURE__ */ __name((_) => de_AssignmentList(_, context), "Assignments"),
-    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: /* @__PURE__ */ __name((_) => de_BonusPaymentList(_, context), "BonusPayments"),
-    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: /* @__PURE__ */ __name((_) => de_HITList(_, context), "HITs"),
-    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: /* @__PURE__ */ __name((_) => de_HITList(_, context), "HITs"),
-    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: /* @__PURE__ */ __name((_) => de_QualificationRequestList(_, context), "QualificationRequests")
-  });
-}, "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: /* @__PURE__ */ __name((_) => de_QualificationTypeList(_, context), "QualificationTypes")
-  });
-}, "de_ListQualificationTypesResponse");
-var de_ListReviewableHITsResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    HITs: /* @__PURE__ */ __name((_) => de_HITList(_, context), "HITs"),
-    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: /* @__PURE__ */ __name((_) => de_ReviewReport(_, context), "AssignmentReviewReport"),
-    HITId: import_smithy_client.expectString,
-    HITReviewPolicy: import_smithy_client._json,
-    HITReviewReport: /* @__PURE__ */ __name((_) => de_ReviewReport(_, context), "HITReviewReport"),
-    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: /* @__PURE__ */ __name((_) => de_QualificationList(_, context), "Qualifications")
-  });
-}, "de_ListWorkersWithQualificationTypeResponse");
-var de_Qualification = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    GrantTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "GrantTime"),
-    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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "SubmitTime"),
-    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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CreationTime"),
-    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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "CompleteTime"),
-    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: /* @__PURE__ */ __name((_) => de_ReviewActionDetailList(_, context), "ReviewActions"),
-    ReviewResults: import_smithy_client._json
-  });
-}, "de_ReviewReport");
-var de_UpdateQualificationTypeResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    QualificationType: /* @__PURE__ */ __name((_) => de_QualificationType(_, context), "QualificationType")
-  });
-}, "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 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");
-// src/commands/AcceptQualificationRequestCommand.ts
-var AcceptQualificationRequestCommand = class 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() {
-  static {
-    __name(this, "AcceptQualificationRequestCommand");
-  }
+const se_UpdateExpirationForHITRequest = (input, context) => {
+    return smithyClient.take(input, {
+        ExpireAt: (_) => _.getTime() / 1_000,
+        HITId: [],
+    });
 };
-// src/commands/ApproveAssignmentCommand.ts
-var ApproveAssignmentCommand = class 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() {
-  static {
-    __name(this, "ApproveAssignmentCommand");
-  }
+const de_Assignment = (output, context) => {
+    return smithyClient.take(output, {
+        AcceptTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        Answer: smithyClient.expectString,
+        ApprovalTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        AssignmentId: smithyClient.expectString,
+        AssignmentStatus: smithyClient.expectString,
+        AutoApprovalTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        Deadline: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        HITId: smithyClient.expectString,
+        RejectionTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        RequesterFeedback: smithyClient.expectString,
+        SubmitTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        WorkerId: smithyClient.expectString,
+    });
 };
-// src/commands/AssociateQualificationWithWorkerCommand.ts
-var AssociateQualificationWithWorkerCommand = class 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() {
-  static {
-    __name(this, "AssociateQualificationWithWorkerCommand");
-  }
+const de_AssignmentList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Assignment(entry);
+    });
+    return retVal;
 };
-// src/commands/CreateAdditionalAssignmentsForHITCommand.ts
-var CreateAdditionalAssignmentsForHITCommand = class 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() {
-  static {
-    __name(this, "CreateAdditionalAssignmentsForHITCommand");
-  }
+const de_BonusPayment = (output, context) => {
+    return smithyClient.take(output, {
+        AssignmentId: smithyClient.expectString,
+        BonusAmount: smithyClient.expectString,
+        GrantTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        Reason: smithyClient.expectString,
+        WorkerId: smithyClient.expectString,
+    });
 };
-// src/commands/CreateHITCommand.ts
-var CreateHITCommand = class 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() {
-  static {
-    __name(this, "CreateHITCommand");
-  }
+const de_BonusPaymentList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_BonusPayment(entry);
+    });
+    return retVal;
 };
-// src/commands/CreateHITTypeCommand.ts
-var CreateHITTypeCommand = class 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() {
-  static {
-    __name(this, "CreateHITTypeCommand");
-  }
+const de_CreateHITResponse = (output, context) => {
+    return smithyClient.take(output, {
+        HIT: (_) => de_HIT(_),
+    });
 };
-// src/commands/CreateHITWithHITTypeCommand.ts
-var CreateHITWithHITTypeCommand = class 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() {
-  static {
-    __name(this, "CreateHITWithHITTypeCommand");
-  }
+const de_CreateHITWithHITTypeResponse = (output, context) => {
+    return smithyClient.take(output, {
+        HIT: (_) => de_HIT(_),
+    });
 };
-// src/commands/CreateQualificationTypeCommand.ts
-var CreateQualificationTypeCommand = class 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() {
-  static {
-    __name(this, "CreateQualificationTypeCommand");
-  }
+const de_CreateQualificationTypeResponse = (output, context) => {
+    return smithyClient.take(output, {
+        QualificationType: (_) => de_QualificationType(_),
+    });
 };
-// src/commands/CreateWorkerBlockCommand.ts
-var CreateWorkerBlockCommand = class 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() {
-  static {
-    __name(this, "CreateWorkerBlockCommand");
-  }
+const de_GetAssignmentResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Assignment: (_) => de_Assignment(_),
+        HIT: (_) => de_HIT(_),
+    });
 };
-// src/commands/DeleteHITCommand.ts
-var DeleteHITCommand = class 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() {
-  static {
-    __name(this, "DeleteHITCommand");
-  }
+const de_GetHITResponse = (output, context) => {
+    return smithyClient.take(output, {
+        HIT: (_) => de_HIT(_),
+    });
 };
-// src/commands/DeleteQualificationTypeCommand.ts
-var DeleteQualificationTypeCommand = class 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() {
-  static {
-    __name(this, "DeleteQualificationTypeCommand");
-  }
+const de_GetQualificationScoreResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Qualification: (_) => de_Qualification(_),
+    });
 };
-// src/commands/DeleteWorkerBlockCommand.ts
-var DeleteWorkerBlockCommand = class 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() {
-  static {
-    __name(this, "DeleteWorkerBlockCommand");
-  }
+const de_GetQualificationTypeResponse = (output, context) => {
+    return smithyClient.take(output, {
+        QualificationType: (_) => de_QualificationType(_),
+    });
 };
-// src/commands/DisassociateQualificationFromWorkerCommand.ts
-var DisassociateQualificationFromWorkerCommand = class 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() {
-  static {
-    __name(this, "DisassociateQualificationFromWorkerCommand");
-  }
+const de_HIT = (output, context) => {
+    return smithyClient.take(output, {
+        AssignmentDurationInSeconds: smithyClient.expectLong,
+        AutoApprovalDelayInSeconds: smithyClient.expectLong,
+        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        Description: smithyClient.expectString,
+        Expiration: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        HITGroupId: smithyClient.expectString,
+        HITId: smithyClient.expectString,
+        HITLayoutId: smithyClient.expectString,
+        HITReviewStatus: smithyClient.expectString,
+        HITStatus: smithyClient.expectString,
+        HITTypeId: smithyClient.expectString,
+        Keywords: smithyClient.expectString,
+        MaxAssignments: smithyClient.expectInt32,
+        NumberOfAssignmentsAvailable: smithyClient.expectInt32,
+        NumberOfAssignmentsCompleted: smithyClient.expectInt32,
+        NumberOfAssignmentsPending: smithyClient.expectInt32,
+        QualificationRequirements: smithyClient._json,
+        Question: smithyClient.expectString,
+        RequesterAnnotation: smithyClient.expectString,
+        Reward: smithyClient.expectString,
+        Title: smithyClient.expectString,
+    });
 };
-// src/commands/GetAccountBalanceCommand.ts
-var GetAccountBalanceCommand = class 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() {
-  static {
-    __name(this, "GetAccountBalanceCommand");
-  }
+const de_HITList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_HIT(entry);
+    });
+    return retVal;
 };
-// src/commands/GetAssignmentCommand.ts
-var GetAssignmentCommand = class 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() {
-  static {
-    __name(this, "GetAssignmentCommand");
-  }
+const de_ListAssignmentsForHITResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Assignments: (_) => de_AssignmentList(_),
+        NextToken: smithyClient.expectString,
+        NumResults: smithyClient.expectInt32,
+    });
 };
-// src/commands/GetFileUploadURLCommand.ts
-var GetFileUploadURLCommand = class 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() {
-  static {
-    __name(this, "GetFileUploadURLCommand");
-  }
+const de_ListBonusPaymentsResponse = (output, context) => {
+    return smithyClient.take(output, {
+        BonusPayments: (_) => de_BonusPaymentList(_),
+        NextToken: smithyClient.expectString,
+        NumResults: smithyClient.expectInt32,
+    });
 };
-// src/commands/GetHITCommand.ts
-var GetHITCommand = class 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() {
-  static {
-    __name(this, "GetHITCommand");
-  }
+const de_ListHITsForQualificationTypeResponse = (output, context) => {
+    return smithyClient.take(output, {
+        HITs: (_) => de_HITList(_),
+        NextToken: smithyClient.expectString,
+        NumResults: smithyClient.expectInt32,
+    });
 };
-// src/commands/GetQualificationScoreCommand.ts
-var GetQualificationScoreCommand = class 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() {
-  static {
-    __name(this, "GetQualificationScoreCommand");
-  }
+const de_ListHITsResponse = (output, context) => {
+    return smithyClient.take(output, {
+        HITs: (_) => de_HITList(_),
+        NextToken: smithyClient.expectString,
+        NumResults: smithyClient.expectInt32,
+    });
 };
-// src/commands/GetQualificationTypeCommand.ts
-var GetQualificationTypeCommand = class 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() {
-  static {
-    __name(this, "GetQualificationTypeCommand");
-  }
+const de_ListQualificationRequestsResponse = (output, context) => {
+    return smithyClient.take(output, {
+        NextToken: smithyClient.expectString,
+        NumResults: smithyClient.expectInt32,
+        QualificationRequests: (_) => de_QualificationRequestList(_),
+    });
 };
-// src/commands/ListAssignmentsForHITCommand.ts
-var ListAssignmentsForHITCommand = class 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() {
-  static {
-    __name(this, "ListAssignmentsForHITCommand");
-  }
+const de_ListQualificationTypesResponse = (output, context) => {
+    return smithyClient.take(output, {
+        NextToken: smithyClient.expectString,
+        NumResults: smithyClient.expectInt32,
+        QualificationTypes: (_) => de_QualificationTypeList(_),
+    });
 };
-// src/commands/ListBonusPaymentsCommand.ts
-var ListBonusPaymentsCommand = class 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() {
-  static {
-    __name(this, "ListBonusPaymentsCommand");
-  }
+const de_ListReviewableHITsResponse = (output, context) => {
+    return smithyClient.take(output, {
+        HITs: (_) => de_HITList(_),
+        NextToken: smithyClient.expectString,
+        NumResults: smithyClient.expectInt32,
+    });
 };
-// src/commands/ListHITsCommand.ts
-var ListHITsCommand = class 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() {
-  static {
-    __name(this, "ListHITsCommand");
-  }
+const de_ListReviewPolicyResultsForHITResponse = (output, context) => {
+    return smithyClient.take(output, {
+        AssignmentReviewPolicy: smithyClient._json,
+        AssignmentReviewReport: (_) => de_ReviewReport(_),
+        HITId: smithyClient.expectString,
+        HITReviewPolicy: smithyClient._json,
+        HITReviewReport: (_) => de_ReviewReport(_),
+        NextToken: smithyClient.expectString,
+    });
 };
-// src/commands/ListHITsForQualificationTypeCommand.ts
-var ListHITsForQualificationTypeCommand = class 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() {
-  static {
-    __name(this, "ListHITsForQualificationTypeCommand");
-  }
+const de_ListWorkersWithQualificationTypeResponse = (output, context) => {
+    return smithyClient.take(output, {
+        NextToken: smithyClient.expectString,
+        NumResults: smithyClient.expectInt32,
+        Qualifications: (_) => de_QualificationList(_),
+    });
 };
-// src/commands/ListQualificationRequestsCommand.ts
-var ListQualificationRequestsCommand = class 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() {
-  static {
-    __name(this, "ListQualificationRequestsCommand");
-  }
+const de_Qualification = (output, context) => {
+    return smithyClient.take(output, {
+        GrantTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        IntegerValue: smithyClient.expectInt32,
+        LocaleValue: smithyClient._json,
+        QualificationTypeId: smithyClient.expectString,
+        Status: smithyClient.expectString,
+        WorkerId: smithyClient.expectString,
+    });
 };
-// src/commands/ListQualificationTypesCommand.ts
-var ListQualificationTypesCommand = class 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() {
-  static {
-    __name(this, "ListQualificationTypesCommand");
-  }
+const de_QualificationList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Qualification(entry);
+    });
+    return retVal;
 };
-// src/commands/ListReviewableHITsCommand.ts
-var ListReviewableHITsCommand = class 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() {
-  static {
-    __name(this, "ListReviewableHITsCommand");
-  }
+const de_QualificationRequest = (output, context) => {
+    return smithyClient.take(output, {
+        Answer: smithyClient.expectString,
+        QualificationRequestId: smithyClient.expectString,
+        QualificationTypeId: smithyClient.expectString,
+        SubmitTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        Test: smithyClient.expectString,
+        WorkerId: smithyClient.expectString,
+    });
 };
-// src/commands/ListReviewPolicyResultsForHITCommand.ts
-var ListReviewPolicyResultsForHITCommand = class 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() {
-  static {
-    __name(this, "ListReviewPolicyResultsForHITCommand");
-  }
+const de_QualificationRequestList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_QualificationRequest(entry);
+    });
+    return retVal;
 };
-// src/commands/ListWorkerBlocksCommand.ts
-var ListWorkerBlocksCommand = class 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() {
-  static {
-    __name(this, "ListWorkerBlocksCommand");
-  }
+const de_QualificationType = (output, context) => {
+    return smithyClient.take(output, {
+        AnswerKey: smithyClient.expectString,
+        AutoGranted: smithyClient.expectBoolean,
+        AutoGrantedValue: smithyClient.expectInt32,
+        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        Description: smithyClient.expectString,
+        IsRequestable: smithyClient.expectBoolean,
+        Keywords: smithyClient.expectString,
+        Name: smithyClient.expectString,
+        QualificationTypeId: smithyClient.expectString,
+        QualificationTypeStatus: smithyClient.expectString,
+        RetryDelayInSeconds: smithyClient.expectLong,
+        Test: smithyClient.expectString,
+        TestDurationInSeconds: smithyClient.expectLong,
+    });
 };
-// src/commands/ListWorkersWithQualificationTypeCommand.ts
-var ListWorkersWithQualificationTypeCommand = class 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() {
-  static {
-    __name(this, "ListWorkersWithQualificationTypeCommand");
-  }
+const de_QualificationTypeList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_QualificationType(entry);
+    });
+    return retVal;
 };
-// src/commands/NotifyWorkersCommand.ts
-var NotifyWorkersCommand = class 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() {
-  static {
-    __name(this, "NotifyWorkersCommand");
-  }
+const de_ReviewActionDetail = (output, context) => {
+    return smithyClient.take(output, {
+        ActionId: smithyClient.expectString,
+        ActionName: smithyClient.expectString,
+        CompleteTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        ErrorCode: smithyClient.expectString,
+        Result: smithyClient.expectString,
+        Status: smithyClient.expectString,
+        TargetId: smithyClient.expectString,
+        TargetType: smithyClient.expectString,
+    });
 };
-// src/commands/RejectAssignmentCommand.ts
-var RejectAssignmentCommand = class 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() {
-  static {
-    __name(this, "RejectAssignmentCommand");
-  }
+const de_ReviewActionDetailList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ReviewActionDetail(entry);
+    });
+    return retVal;
 };
-// src/commands/RejectQualificationRequestCommand.ts
-var RejectQualificationRequestCommand = class 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() {
-  static {
-    __name(this, "RejectQualificationRequestCommand");
-  }
+const de_ReviewReport = (output, context) => {
+    return smithyClient.take(output, {
+        ReviewActions: (_) => de_ReviewActionDetailList(_),
+        ReviewResults: smithyClient._json,
+    });
 };
+const de_UpdateQualificationTypeResponse = (output, context) => {
+    return smithyClient.take(output, {
+        QualificationType: (_) => de_QualificationType(_),
+    });
+};
+const deserializeMetadata = (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"],
+});
+const throwDefaultError = smithyClient.withBaseException(MTurkServiceException);
+const buildHttpRpcRequest = 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 (body !== undefined) {
+        contents.body = body;
+    }
+    return new protocolHttp.HttpRequest(contents);
+};
+function sharedHeaders(operation) {
+    return {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": `MTurkRequesterServiceV20170117.${operation}`,
+    };
+}
-// src/commands/SendBonusCommand.ts
+class AcceptQualificationRequestCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "AcceptQualificationRequest", {})
+    .n("MTurkClient", "AcceptQualificationRequestCommand")
+    .f(void 0, void 0)
+    .ser(se_AcceptQualificationRequestCommand)
+    .de(de_AcceptQualificationRequestCommand)
+    .build() {
+}
+class ApproveAssignmentCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ApproveAssignment", {})
+    .n("MTurkClient", "ApproveAssignmentCommand")
+    .f(void 0, void 0)
+    .ser(se_ApproveAssignmentCommand)
+    .de(de_ApproveAssignmentCommand)
+    .build() {
+}
+class AssociateQualificationWithWorkerCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "AssociateQualificationWithWorker", {})
+    .n("MTurkClient", "AssociateQualificationWithWorkerCommand")
+    .f(void 0, void 0)
+    .ser(se_AssociateQualificationWithWorkerCommand)
+    .de(de_AssociateQualificationWithWorkerCommand)
+    .build() {
+}
-var SendBonusCommand = class 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() {
-  static {
-    __name(this, "SendBonusCommand");
-  }
-};
+class CreateAdditionalAssignmentsForHITCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "CreateAdditionalAssignmentsForHIT", {})
+    .n("MTurkClient", "CreateAdditionalAssignmentsForHITCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateAdditionalAssignmentsForHITCommand)
+    .de(de_CreateAdditionalAssignmentsForHITCommand)
+    .build() {
+}
-// src/commands/SendTestEventNotificationCommand.ts
+class CreateHITCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "CreateHIT", {})
+    .n("MTurkClient", "CreateHITCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateHITCommand)
+    .de(de_CreateHITCommand)
+    .build() {
+}
+class CreateHITTypeCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "CreateHITType", {})
+    .n("MTurkClient", "CreateHITTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateHITTypeCommand)
+    .de(de_CreateHITTypeCommand)
+    .build() {
+}
+class CreateHITWithHITTypeCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "CreateHITWithHITType", {})
+    .n("MTurkClient", "CreateHITWithHITTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateHITWithHITTypeCommand)
+    .de(de_CreateHITWithHITTypeCommand)
+    .build() {
+}
-var SendTestEventNotificationCommand = class 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() {
-  static {
-    __name(this, "SendTestEventNotificationCommand");
-  }
-};
+class CreateQualificationTypeCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "CreateQualificationType", {})
+    .n("MTurkClient", "CreateQualificationTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateQualificationTypeCommand)
+    .de(de_CreateQualificationTypeCommand)
+    .build() {
+}
-// src/commands/UpdateExpirationForHITCommand.ts
+class CreateWorkerBlockCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "CreateWorkerBlock", {})
+    .n("MTurkClient", "CreateWorkerBlockCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateWorkerBlockCommand)
+    .de(de_CreateWorkerBlockCommand)
+    .build() {
+}
+class DeleteHITCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "DeleteHIT", {})
+    .n("MTurkClient", "DeleteHITCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteHITCommand)
+    .de(de_DeleteHITCommand)
+    .build() {
+}
+class DeleteQualificationTypeCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "DeleteQualificationType", {})
+    .n("MTurkClient", "DeleteQualificationTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteQualificationTypeCommand)
+    .de(de_DeleteQualificationTypeCommand)
+    .build() {
+}
-var UpdateExpirationForHITCommand = class 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() {
-  static {
-    __name(this, "UpdateExpirationForHITCommand");
-  }
-};
+class DeleteWorkerBlockCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "DeleteWorkerBlock", {})
+    .n("MTurkClient", "DeleteWorkerBlockCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteWorkerBlockCommand)
+    .de(de_DeleteWorkerBlockCommand)
+    .build() {
+}
-// src/commands/UpdateHITReviewStatusCommand.ts
+class DisassociateQualificationFromWorkerCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "DisassociateQualificationFromWorker", {})
+    .n("MTurkClient", "DisassociateQualificationFromWorkerCommand")
+    .f(void 0, void 0)
+    .ser(se_DisassociateQualificationFromWorkerCommand)
+    .de(de_DisassociateQualificationFromWorkerCommand)
+    .build() {
+}
+class GetAccountBalanceCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "GetAccountBalance", {})
+    .n("MTurkClient", "GetAccountBalanceCommand")
+    .f(void 0, void 0)
+    .ser(se_GetAccountBalanceCommand)
+    .de(de_GetAccountBalanceCommand)
+    .build() {
+}
+class GetAssignmentCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "GetAssignment", {})
+    .n("MTurkClient", "GetAssignmentCommand")
+    .f(void 0, void 0)
+    .ser(se_GetAssignmentCommand)
+    .de(de_GetAssignmentCommand)
+    .build() {
+}
-var UpdateHITReviewStatusCommand = class 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() {
-  static {
-    __name(this, "UpdateHITReviewStatusCommand");
-  }
-};
+class GetFileUploadURLCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "GetFileUploadURL", {})
+    .n("MTurkClient", "GetFileUploadURLCommand")
+    .f(void 0, void 0)
+    .ser(se_GetFileUploadURLCommand)
+    .de(de_GetFileUploadURLCommand)
+    .build() {
+}
-// src/commands/UpdateHITTypeOfHITCommand.ts
+class GetHITCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "GetHIT", {})
+    .n("MTurkClient", "GetHITCommand")
+    .f(void 0, void 0)
+    .ser(se_GetHITCommand)
+    .de(de_GetHITCommand)
+    .build() {
+}
+class GetQualificationScoreCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "GetQualificationScore", {})
+    .n("MTurkClient", "GetQualificationScoreCommand")
+    .f(void 0, void 0)
+    .ser(se_GetQualificationScoreCommand)
+    .de(de_GetQualificationScoreCommand)
+    .build() {
+}
+class GetQualificationTypeCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "GetQualificationType", {})
+    .n("MTurkClient", "GetQualificationTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_GetQualificationTypeCommand)
+    .de(de_GetQualificationTypeCommand)
+    .build() {
+}
-var UpdateHITTypeOfHITCommand = class 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() {
-  static {
-    __name(this, "UpdateHITTypeOfHITCommand");
-  }
-};
+class ListAssignmentsForHITCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ListAssignmentsForHIT", {})
+    .n("MTurkClient", "ListAssignmentsForHITCommand")
+    .f(void 0, void 0)
+    .ser(se_ListAssignmentsForHITCommand)
+    .de(de_ListAssignmentsForHITCommand)
+    .build() {
+}
-// src/commands/UpdateNotificationSettingsCommand.ts
+class ListBonusPaymentsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ListBonusPayments", {})
+    .n("MTurkClient", "ListBonusPaymentsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListBonusPaymentsCommand)
+    .de(de_ListBonusPaymentsCommand)
+    .build() {
+}
+class ListHITsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ListHITs", {})
+    .n("MTurkClient", "ListHITsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListHITsCommand)
+    .de(de_ListHITsCommand)
+    .build() {
+}
+class ListHITsForQualificationTypeCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ListHITsForQualificationType", {})
+    .n("MTurkClient", "ListHITsForQualificationTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_ListHITsForQualificationTypeCommand)
+    .de(de_ListHITsForQualificationTypeCommand)
+    .build() {
+}
-var UpdateNotificationSettingsCommand = class 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() {
-  static {
-    __name(this, "UpdateNotificationSettingsCommand");
-  }
-};
+class ListQualificationRequestsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ListQualificationRequests", {})
+    .n("MTurkClient", "ListQualificationRequestsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListQualificationRequestsCommand)
+    .de(de_ListQualificationRequestsCommand)
+    .build() {
+}
-// src/commands/UpdateQualificationTypeCommand.ts
+class ListQualificationTypesCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ListQualificationTypes", {})
+    .n("MTurkClient", "ListQualificationTypesCommand")
+    .f(void 0, void 0)
+    .ser(se_ListQualificationTypesCommand)
+    .de(de_ListQualificationTypesCommand)
+    .build() {
+}
+class ListReviewableHITsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ListReviewableHITs", {})
+    .n("MTurkClient", "ListReviewableHITsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListReviewableHITsCommand)
+    .de(de_ListReviewableHITsCommand)
+    .build() {
+}
+class ListReviewPolicyResultsForHITCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ListReviewPolicyResultsForHIT", {})
+    .n("MTurkClient", "ListReviewPolicyResultsForHITCommand")
+    .f(void 0, void 0)
+    .ser(se_ListReviewPolicyResultsForHITCommand)
+    .de(de_ListReviewPolicyResultsForHITCommand)
+    .build() {
+}
-var UpdateQualificationTypeCommand = class 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() {
-  static {
-    __name(this, "UpdateQualificationTypeCommand");
-  }
-};
+class ListWorkerBlocksCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ListWorkerBlocks", {})
+    .n("MTurkClient", "ListWorkerBlocksCommand")
+    .f(void 0, void 0)
+    .ser(se_ListWorkerBlocksCommand)
+    .de(de_ListWorkerBlocksCommand)
+    .build() {
+}
-// 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 extends MTurkClient {
-  static {
-    __name(this, "MTurk");
-  }
-};
-(0, import_smithy_client.createAggregatedClient)(commands, MTurk);
+class ListWorkersWithQualificationTypeCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "ListWorkersWithQualificationType", {})
+    .n("MTurkClient", "ListWorkersWithQualificationTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_ListWorkersWithQualificationTypeCommand)
+    .de(de_ListWorkersWithQualificationTypeCommand)
+    .build() {
+}
-// src/pagination/ListAssignmentsForHITPaginator.ts
+class NotifyWorkersCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "NotifyWorkers", {})
+    .n("MTurkClient", "NotifyWorkersCommand")
+    .f(void 0, void 0)
+    .ser(se_NotifyWorkersCommand)
+    .de(de_NotifyWorkersCommand)
+    .build() {
+}
-var paginateListAssignmentsForHIT = (0, import_core.createPaginator)(MTurkClient, ListAssignmentsForHITCommand, "NextToken", "NextToken", "MaxResults");
+class RejectAssignmentCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "RejectAssignment", {})
+    .n("MTurkClient", "RejectAssignmentCommand")
+    .f(void 0, void 0)
+    .ser(se_RejectAssignmentCommand)
+    .de(de_RejectAssignmentCommand)
+    .build() {
+}
-// src/pagination/ListBonusPaymentsPaginator.ts
+class RejectQualificationRequestCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "RejectQualificationRequest", {})
+    .n("MTurkClient", "RejectQualificationRequestCommand")
+    .f(void 0, void 0)
+    .ser(se_RejectQualificationRequestCommand)
+    .de(de_RejectQualificationRequestCommand)
+    .build() {
+}
-var paginateListBonusPayments = (0, import_core.createPaginator)(MTurkClient, ListBonusPaymentsCommand, "NextToken", "NextToken", "MaxResults");
+class SendBonusCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "SendBonus", {})
+    .n("MTurkClient", "SendBonusCommand")
+    .f(void 0, void 0)
+    .ser(se_SendBonusCommand)
+    .de(de_SendBonusCommand)
+    .build() {
+}
-// src/pagination/ListHITsForQualificationTypePaginator.ts
+class SendTestEventNotificationCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "SendTestEventNotification", {})
+    .n("MTurkClient", "SendTestEventNotificationCommand")
+    .f(void 0, void 0)
+    .ser(se_SendTestEventNotificationCommand)
+    .de(de_SendTestEventNotificationCommand)
+    .build() {
+}
-var paginateListHITsForQualificationType = (0, import_core.createPaginator)(MTurkClient, ListHITsForQualificationTypeCommand, "NextToken", "NextToken", "MaxResults");
+class UpdateExpirationForHITCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "UpdateExpirationForHIT", {})
+    .n("MTurkClient", "UpdateExpirationForHITCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateExpirationForHITCommand)
+    .de(de_UpdateExpirationForHITCommand)
+    .build() {
+}
-// src/pagination/ListHITsPaginator.ts
+class UpdateHITReviewStatusCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "UpdateHITReviewStatus", {})
+    .n("MTurkClient", "UpdateHITReviewStatusCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateHITReviewStatusCommand)
+    .de(de_UpdateHITReviewStatusCommand)
+    .build() {
+}
-var paginateListHITs = (0, import_core.createPaginator)(MTurkClient, ListHITsCommand, "NextToken", "NextToken", "MaxResults");
+class UpdateHITTypeOfHITCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "UpdateHITTypeOfHIT", {})
+    .n("MTurkClient", "UpdateHITTypeOfHITCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateHITTypeOfHITCommand)
+    .de(de_UpdateHITTypeOfHITCommand)
+    .build() {
+}
-// src/pagination/ListQualificationRequestsPaginator.ts
+class UpdateNotificationSettingsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "UpdateNotificationSettings", {})
+    .n("MTurkClient", "UpdateNotificationSettingsCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateNotificationSettingsCommand)
+    .de(de_UpdateNotificationSettingsCommand)
+    .build() {
+}
-var paginateListQualificationRequests = (0, import_core.createPaginator)(MTurkClient, ListQualificationRequestsCommand, "NextToken", "NextToken", "MaxResults");
+class UpdateQualificationTypeCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("MTurkRequesterServiceV20170117", "UpdateQualificationType", {})
+    .n("MTurkClient", "UpdateQualificationTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateQualificationTypeCommand)
+    .de(de_UpdateQualificationTypeCommand)
+    .build() {
+}
-// src/pagination/ListQualificationTypesPaginator.ts
+const 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,
+};
+class MTurk extends MTurkClient {
+}
+smithyClient.createAggregatedClient(commands, MTurk);
-var paginateListQualificationTypes = (0, import_core.createPaginator)(MTurkClient, ListQualificationTypesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListAssignmentsForHIT = core.createPaginator(MTurkClient, ListAssignmentsForHITCommand, "NextToken", "NextToken", "MaxResults");
-// src/pagination/ListReviewPolicyResultsForHITPaginator.ts
+const paginateListBonusPayments = core.createPaginator(MTurkClient, ListBonusPaymentsCommand, "NextToken", "NextToken", "MaxResults");
-var paginateListReviewPolicyResultsForHIT = (0, import_core.createPaginator)(MTurkClient, ListReviewPolicyResultsForHITCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListHITsForQualificationType = core.createPaginator(MTurkClient, ListHITsForQualificationTypeCommand, "NextToken", "NextToken", "MaxResults");
-// src/pagination/ListReviewableHITsPaginator.ts
+const paginateListHITs = core.createPaginator(MTurkClient, ListHITsCommand, "NextToken", "NextToken", "MaxResults");
-var paginateListReviewableHITs = (0, import_core.createPaginator)(MTurkClient, ListReviewableHITsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListQualificationRequests = core.createPaginator(MTurkClient, ListQualificationRequestsCommand, "NextToken", "NextToken", "MaxResults");
-// src/pagination/ListWorkerBlocksPaginator.ts
+const paginateListQualificationTypes = core.createPaginator(MTurkClient, ListQualificationTypesCommand, "NextToken", "NextToken", "MaxResults");
-var paginateListWorkerBlocks = (0, import_core.createPaginator)(MTurkClient, ListWorkerBlocksCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListReviewPolicyResultsForHIT = core.createPaginator(MTurkClient, ListReviewPolicyResultsForHITCommand, "NextToken", "NextToken", "MaxResults");
-// src/pagination/ListWorkersWithQualificationTypePaginator.ts
+const paginateListReviewableHITs = core.createPaginator(MTurkClient, ListReviewableHITsCommand, "NextToken", "NextToken", "MaxResults");
-var paginateListWorkersWithQualificationType = (0, import_core.createPaginator)(MTurkClient, ListWorkersWithQualificationTypeCommand, "NextToken", "NextToken", "MaxResults");
-// Annotate the CommonJS export names for ESM import in node:
+const paginateListWorkerBlocks = core.createPaginator(MTurkClient, ListWorkerBlocksCommand, "NextToken", "NextToken", "MaxResults");
-0 && (module.exports = {
-  MTurkServiceException,
-  __Client,
-  MTurkClient,
-  MTurk,
-  $Command,
-  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,
-  ListReviewPolicyResultsForHITCommand,
-  ListReviewableHITsCommand,
-  ListWorkerBlocksCommand,
-  ListWorkersWithQualificationTypeCommand,
-  NotifyWorkersCommand,
-  RejectAssignmentCommand,
-  RejectQualificationRequestCommand,
-  SendBonusCommand,
-  SendTestEventNotificationCommand,
-  UpdateExpirationForHITCommand,
-  UpdateHITReviewStatusCommand,
-  UpdateHITTypeOfHITCommand,
-  UpdateNotificationSettingsCommand,
-  UpdateQualificationTypeCommand,
-  paginateListAssignmentsForHIT,
-  paginateListBonusPayments,
-  paginateListHITsForQualificationType,
-  paginateListHITs,
-  paginateListQualificationRequests,
-  paginateListQualificationTypes,
-  paginateListReviewPolicyResultsForHIT,
-  paginateListReviewableHITs,
-  paginateListWorkerBlocks,
-  paginateListWorkersWithQualificationType,
-  RequestError,
-  ServiceFault,
-  AssignmentStatus,
-  Comparator,
-  HITAccessActions,
-  HITReviewStatus,
-  HITStatus,
-  QualificationTypeStatus,
-  EventType,
-  QualificationStatus,
-  ReviewableHITStatus,
-  ReviewPolicyLevel,
-  ReviewActionStatus,
-  NotifyWorkersFailureCode,
-  NotificationTransport
-});
+const paginateListWorkersWithQualificationType = core.createPaginator(MTurkClient, ListWorkersWithQualificationTypeCommand, "NextToken", "NextToken", "MaxResults");
+Object.defineProperty(exports, "$Command", {
+    enumerable: true,
+    get: function () { return smithyClient.Command; }
+});
+Object.defineProperty(exports, "__Client", {
+    enumerable: true,
+    get: function () { return smithyClient.Client; }
+});
+exports.AcceptQualificationRequestCommand = AcceptQualificationRequestCommand;
+exports.ApproveAssignmentCommand = ApproveAssignmentCommand;
+exports.AssignmentStatus = AssignmentStatus;
+exports.AssociateQualificationWithWorkerCommand = AssociateQualificationWithWorkerCommand;
+exports.Comparator = Comparator;
+exports.CreateAdditionalAssignmentsForHITCommand = CreateAdditionalAssignmentsForHITCommand;
+exports.CreateHITCommand = CreateHITCommand;
+exports.CreateHITTypeCommand = CreateHITTypeCommand;
+exports.CreateHITWithHITTypeCommand = CreateHITWithHITTypeCommand;
+exports.CreateQualificationTypeCommand = CreateQualificationTypeCommand;
+exports.CreateWorkerBlockCommand = CreateWorkerBlockCommand;
+exports.DeleteHITCommand = DeleteHITCommand;
+exports.DeleteQualificationTypeCommand = DeleteQualificationTypeCommand;
+exports.DeleteWorkerBlockCommand = DeleteWorkerBlockCommand;
+exports.DisassociateQualificationFromWorkerCommand = DisassociateQualificationFromWorkerCommand;
+exports.EventType = EventType;
+exports.GetAccountBalanceCommand = GetAccountBalanceCommand;
+exports.GetAssignmentCommand = GetAssignmentCommand;
+exports.GetFileUploadURLCommand = GetFileUploadURLCommand;
+exports.GetHITCommand = GetHITCommand;
+exports.GetQualificationScoreCommand = GetQualificationScoreCommand;
+exports.GetQualificationTypeCommand = GetQualificationTypeCommand;
+exports.HITAccessActions = HITAccessActions;
+exports.HITReviewStatus = HITReviewStatus;
+exports.HITStatus = HITStatus;
+exports.ListAssignmentsForHITCommand = ListAssignmentsForHITCommand;
+exports.ListBonusPaymentsCommand = ListBonusPaymentsCommand;
+exports.ListHITsCommand = ListHITsCommand;
+exports.ListHITsForQualificationTypeCommand = ListHITsForQualificationTypeCommand;
+exports.ListQualificationRequestsCommand = ListQualificationRequestsCommand;
+exports.ListQualificationTypesCommand = ListQualificationTypesCommand;
+exports.ListReviewPolicyResultsForHITCommand = ListReviewPolicyResultsForHITCommand;
+exports.ListReviewableHITsCommand = ListReviewableHITsCommand;
+exports.ListWorkerBlocksCommand = ListWorkerBlocksCommand;
+exports.ListWorkersWithQualificationTypeCommand = ListWorkersWithQualificationTypeCommand;
+exports.MTurk = MTurk;
+exports.MTurkClient = MTurkClient;
+exports.MTurkServiceException = MTurkServiceException;
+exports.NotificationTransport = NotificationTransport;
+exports.NotifyWorkersCommand = NotifyWorkersCommand;
+exports.NotifyWorkersFailureCode = NotifyWorkersFailureCode;
+exports.QualificationStatus = QualificationStatus;
+exports.QualificationTypeStatus = QualificationTypeStatus;
+exports.RejectAssignmentCommand = RejectAssignmentCommand;
+exports.RejectQualificationRequestCommand = RejectQualificationRequestCommand;
+exports.RequestError = RequestError;
+exports.ReviewActionStatus = ReviewActionStatus;
+exports.ReviewPolicyLevel = ReviewPolicyLevel;
+exports.ReviewableHITStatus = ReviewableHITStatus;
+exports.SendBonusCommand = SendBonusCommand;
+exports.SendTestEventNotificationCommand = SendTestEventNotificationCommand;
+exports.ServiceFault = ServiceFault;
+exports.UpdateExpirationForHITCommand = UpdateExpirationForHITCommand;
+exports.UpdateHITReviewStatusCommand = UpdateHITReviewStatusCommand;
+exports.UpdateHITTypeOfHITCommand = UpdateHITTypeOfHITCommand;
+exports.UpdateNotificationSettingsCommand = UpdateNotificationSettingsCommand;
+exports.UpdateQualificationTypeCommand = UpdateQualificationTypeCommand;
+exports.paginateListAssignmentsForHIT = paginateListAssignmentsForHIT;
+exports.paginateListBonusPayments = paginateListBonusPayments;
+exports.paginateListHITs = paginateListHITs;
+exports.paginateListHITsForQualificationType = paginateListHITsForQualificationType;
+exports.paginateListQualificationRequests = paginateListQualificationRequests;
+exports.paginateListQualificationTypes = paginateListQualificationTypes;
+exports.paginateListReviewPolicyResultsForHIT = paginateListReviewPolicyResultsForHIT;
+exports.paginateListReviewableHITs = paginateListReviewableHITs;
+exports.paginateListWorkerBlocks = paginateListWorkerBlocks;
+exports.paginateListWorkersWithQualificationType = paginateListWorkersWithQualificationType;