@aws-sdk/client-mturk 3.35.0 → 3.38.0

package/src/commands/AssociateQualificationWithWorkerCommand.ts

@@ -1,123 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { AssociateQualificationWithWorkerRequest, AssociateQualificationWithWorkerResponse } from "../models/models_0";
-import { MTurkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MTurkClient";
-import {
-  deserializeAws_json1_1AssociateQualificationWithWorkerCommand,
-  serializeAws_json1_1AssociateQualificationWithWorkerCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface AssociateQualificationWithWorkerCommandInput extends AssociateQualificationWithWorkerRequest {}
-export interface AssociateQualificationWithWorkerCommandOutput
-  extends AssociateQualificationWithWorkerResponse,
-    __MetadataBearer {}
-
-/**
- * <p>
- *             The <code>AssociateQualificationWithWorker</code> operation gives a Worker a
- *             Qualification. <code>AssociateQualificationWithWorker</code> does not require that the Worker
- *             submit a Qualification request. It gives the Qualification directly to the Worker.
- *         </p>
- *
- *         <p>
- *             You can only assign a Qualification of a Qualification type that you created (using
- *             the <code>CreateQualificationType</code> operation).
- *         </p>
- *
- *         <note>
- *             <p>
- *                 Note: <code>AssociateQualificationWithWorker</code> does not affect any pending Qualification
- *                 requests for the Qualification by the Worker. If you assign a Qualification to a
- *                 Worker, then later grant a Qualification request made by the Worker, the granting of
- *                 the request may modify the Qualification score. To resolve a pending Qualification
- *                 request without affecting the Qualification the Worker already has, reject the
- *                 request with the <code>RejectQualificationRequest</code> operation.
- *             </p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MTurkClient, AssociateQualificationWithWorkerCommand } from "@aws-sdk/client-mturk"; // ES Modules import
- * // const { MTurkClient, AssociateQualificationWithWorkerCommand } = require("@aws-sdk/client-mturk"); // CommonJS import
- * const client = new MTurkClient(config);
- * const command = new AssociateQualificationWithWorkerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateQualificationWithWorkerCommandInput} for command's `input` shape.
- * @see {@link AssociateQualificationWithWorkerCommandOutput} for command's `response` shape.
- * @see {@link MTurkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class AssociateQualificationWithWorkerCommand extends $Command<
-  AssociateQualificationWithWorkerCommandInput,
-  AssociateQualificationWithWorkerCommandOutput,
-  MTurkClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: AssociateQualificationWithWorkerCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MTurkClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<AssociateQualificationWithWorkerCommandInput, AssociateQualificationWithWorkerCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MTurkClient";
-    const commandName = "AssociateQualificationWithWorkerCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: AssociateQualificationWithWorkerRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: AssociateQualificationWithWorkerResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: AssociateQualificationWithWorkerCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_1AssociateQualificationWithWorkerCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<AssociateQualificationWithWorkerCommandOutput> {
-    return deserializeAws_json1_1AssociateQualificationWithWorkerCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateAdditionalAssignmentsForHITCommand.ts

@@ -1,128 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import {
-  CreateAdditionalAssignmentsForHITRequest,
-  CreateAdditionalAssignmentsForHITResponse,
-} from "../models/models_0";
-import { MTurkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MTurkClient";
-import {
-  deserializeAws_json1_1CreateAdditionalAssignmentsForHITCommand,
-  serializeAws_json1_1CreateAdditionalAssignmentsForHITCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface CreateAdditionalAssignmentsForHITCommandInput extends CreateAdditionalAssignmentsForHITRequest {}
-export interface CreateAdditionalAssignmentsForHITCommandOutput
-  extends CreateAdditionalAssignmentsForHITResponse,
-    __MetadataBearer {}
-
-/**
- * <p>
- *             The
- *             <code>CreateAdditionalAssignmentsForHIT</code>
- *             operation increases the maximum number of assignments of an existing HIT.
- *         </p>
- *         <p>
- *             To extend the maximum number of assignments, specify the number of additional assignments.</p>
- *         <note>
- *             <ul>
- *                <li>
- *                     <p>HITs created with fewer than 10 assignments cannot be extended to have 10 or more assignments. Attempting to add assignments in a way that brings the total number of assignments for a HIT from fewer than 10 assignments to 10 or more
- *                         assignments will result in an
- *                         <code>AWS.MechanicalTurk.InvalidMaximumAssignmentsIncrease</code>
- *                         exception.</p>
- *                 </li>
- *                <li>
- *                     <p>HITs that were created before July 22, 2015 cannot be extended. Attempting to extend HITs that were created before July 22, 2015 will result in an
- *                         <code>AWS.MechanicalTurk.HITTooOldForExtension</code>
- *                         exception.
- *                     </p>
- *                 </li>
- *             </ul>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MTurkClient, CreateAdditionalAssignmentsForHITCommand } from "@aws-sdk/client-mturk"; // ES Modules import
- * // const { MTurkClient, CreateAdditionalAssignmentsForHITCommand } = require("@aws-sdk/client-mturk"); // CommonJS import
- * const client = new MTurkClient(config);
- * const command = new CreateAdditionalAssignmentsForHITCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateAdditionalAssignmentsForHITCommandInput} for command's `input` shape.
- * @see {@link CreateAdditionalAssignmentsForHITCommandOutput} for command's `response` shape.
- * @see {@link MTurkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateAdditionalAssignmentsForHITCommand extends $Command<
-  CreateAdditionalAssignmentsForHITCommandInput,
-  CreateAdditionalAssignmentsForHITCommandOutput,
-  MTurkClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateAdditionalAssignmentsForHITCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MTurkClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateAdditionalAssignmentsForHITCommandInput, CreateAdditionalAssignmentsForHITCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MTurkClient";
-    const commandName = "CreateAdditionalAssignmentsForHITCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateAdditionalAssignmentsForHITRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateAdditionalAssignmentsForHITResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: CreateAdditionalAssignmentsForHITCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_json1_1CreateAdditionalAssignmentsForHITCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateAdditionalAssignmentsForHITCommandOutput> {
-    return deserializeAws_json1_1CreateAdditionalAssignmentsForHITCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateHITCommand.ts

@@ -1,108 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { CreateHITRequest, CreateHITResponse } from "../models/models_0";
-import { MTurkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MTurkClient";
-import { deserializeAws_json1_1CreateHITCommand, serializeAws_json1_1CreateHITCommand } from "../protocols/Aws_json1_1";
-
-export interface CreateHITCommandInput extends CreateHITRequest {}
-export interface CreateHITCommandOutput extends CreateHITResponse, __MetadataBearer {}
-
-/**
- * <p>The <code>CreateHIT</code> operation creates a new Human Intelligence Task (HIT).
- *             The new HIT is made available for Workers to find and accept on the Amazon Mechanical
- *             Turk website. </p>
- *         <p>
- *             This operation allows you to specify a new HIT by passing in values for the properties of the HIT, such as its title, reward amount and number of assignments. When you pass these values to <code>CreateHIT</code>, a new HIT is created for you, with a new <code>HITTypeID</code>. The HITTypeID can be used to create additional HITs in the future without needing to specify common parameters such as the title, description and reward amount each time.</p>
- *         <p> An alternative way to create HITs is to first generate a HITTypeID using the <code>CreateHITType</code> operation and then call the <code>CreateHITWithHITType</code> operation. This is the recommended best practice for Requesters who are creating large numbers of HITs.
- *         </p>
- *
- *         <p>CreateHIT also supports several ways to provide question data: by providing a value
- *             for the <code>Question</code> parameter that fully specifies the contents of the HIT, or by providing
- *             a <code>HitLayoutId</code> and associated <code>HitLayoutParameters</code>.
- *         </p>
- *
- *         <note>
- *             <p> If a HIT is created with 10 or more maximum assignments, there is an additional fee. For more information, see
- *             <a href="https://requester.mturk.com/pricing">Amazon Mechanical Turk Pricing</a>.</p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MTurkClient, CreateHITCommand } from "@aws-sdk/client-mturk"; // ES Modules import
- * // const { MTurkClient, CreateHITCommand } = require("@aws-sdk/client-mturk"); // CommonJS import
- * const client = new MTurkClient(config);
- * const command = new CreateHITCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateHITCommandInput} for command's `input` shape.
- * @see {@link CreateHITCommandOutput} for command's `response` shape.
- * @see {@link MTurkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateHITCommand extends $Command<
-  CreateHITCommandInput,
-  CreateHITCommandOutput,
-  MTurkClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateHITCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MTurkClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateHITCommandInput, CreateHITCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MTurkClient";
-    const commandName = "CreateHITCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateHITRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateHITResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateHITCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1CreateHITCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateHITCommandOutput> {
-    return deserializeAws_json1_1CreateHITCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateHITTypeCommand.ts

@@ -1,100 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { CreateHITTypeRequest, CreateHITTypeResponse } from "../models/models_0";
-import { MTurkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MTurkClient";
-import {
-  deserializeAws_json1_1CreateHITTypeCommand,
-  serializeAws_json1_1CreateHITTypeCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface CreateHITTypeCommandInput extends CreateHITTypeRequest {}
-export interface CreateHITTypeCommandOutput extends CreateHITTypeResponse, __MetadataBearer {}
-
-/**
- * <p>
- *             The <code>CreateHITType</code> operation creates a new HIT type. This operation
- *             allows you to define a standard set of HIT properties to use when creating HITs.
- *             If you register a HIT type with values that match an existing HIT type, the HIT type
- *             ID of the existing type will be returned.
- *         </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MTurkClient, CreateHITTypeCommand } from "@aws-sdk/client-mturk"; // ES Modules import
- * // const { MTurkClient, CreateHITTypeCommand } = require("@aws-sdk/client-mturk"); // CommonJS import
- * const client = new MTurkClient(config);
- * const command = new CreateHITTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateHITTypeCommandInput} for command's `input` shape.
- * @see {@link CreateHITTypeCommandOutput} for command's `response` shape.
- * @see {@link MTurkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateHITTypeCommand extends $Command<
-  CreateHITTypeCommandInput,
-  CreateHITTypeCommandOutput,
-  MTurkClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateHITTypeCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MTurkClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateHITTypeCommandInput, CreateHITTypeCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MTurkClient";
-    const commandName = "CreateHITTypeCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateHITTypeRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateHITTypeResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateHITTypeCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1CreateHITTypeCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateHITTypeCommandOutput> {
-    return deserializeAws_json1_1CreateHITTypeCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateHITWithHITTypeCommand.ts

@@ -1,112 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { CreateHITWithHITTypeRequest, CreateHITWithHITTypeResponse } from "../models/models_0";
-import { MTurkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MTurkClient";
-import {
-  deserializeAws_json1_1CreateHITWithHITTypeCommand,
-  serializeAws_json1_1CreateHITWithHITTypeCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface CreateHITWithHITTypeCommandInput extends CreateHITWithHITTypeRequest {}
-export interface CreateHITWithHITTypeCommandOutput extends CreateHITWithHITTypeResponse, __MetadataBearer {}
-
-/**
- * <p>
- *             The <code>CreateHITWithHITType</code> operation creates a new Human Intelligence Task (HIT)
- *             using an existing HITTypeID generated by the <code>CreateHITType</code> operation.
- *         </p>
- *         <p>
- *             This is an alternative way to create HITs from the <code>CreateHIT</code> operation.
- *             This is the recommended best practice for Requesters who are creating large numbers of HITs.
- *         </p>
- *         <p>CreateHITWithHITType also supports several ways to provide question data:
- *             by providing a value for the <code>Question</code> parameter that fully specifies the contents of the HIT,
- *             or by providing a <code>HitLayoutId</code> and associated <code>HitLayoutParameters</code>.
- *         </p>
- *         <note>
- *             <p>
- *                 If a HIT is created with 10 or more maximum assignments, there is an additional fee.
- *                 For more information, see <a href="https://requester.mturk.com/pricing">Amazon Mechanical Turk Pricing</a>.
- *             </p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MTurkClient, CreateHITWithHITTypeCommand } from "@aws-sdk/client-mturk"; // ES Modules import
- * // const { MTurkClient, CreateHITWithHITTypeCommand } = require("@aws-sdk/client-mturk"); // CommonJS import
- * const client = new MTurkClient(config);
- * const command = new CreateHITWithHITTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateHITWithHITTypeCommandInput} for command's `input` shape.
- * @see {@link CreateHITWithHITTypeCommandOutput} for command's `response` shape.
- * @see {@link MTurkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateHITWithHITTypeCommand extends $Command<
-  CreateHITWithHITTypeCommandInput,
-  CreateHITWithHITTypeCommandOutput,
-  MTurkClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateHITWithHITTypeCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MTurkClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateHITWithHITTypeCommandInput, CreateHITWithHITTypeCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MTurkClient";
-    const commandName = "CreateHITWithHITTypeCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateHITWithHITTypeRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateHITWithHITTypeResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateHITWithHITTypeCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1CreateHITWithHITTypeCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateHITWithHITTypeCommandOutput> {
-    return deserializeAws_json1_1CreateHITWithHITTypeCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/src/commands/CreateQualificationTypeCommand.ts

@@ -1,101 +0,0 @@
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  MiddlewareStack,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-import { CreateQualificationTypeRequest, CreateQualificationTypeResponse } from "../models/models_0";
-import { MTurkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MTurkClient";
-import {
-  deserializeAws_json1_1CreateQualificationTypeCommand,
-  serializeAws_json1_1CreateQualificationTypeCommand,
-} from "../protocols/Aws_json1_1";
-
-export interface CreateQualificationTypeCommandInput extends CreateQualificationTypeRequest {}
-export interface CreateQualificationTypeCommandOutput extends CreateQualificationTypeResponse, __MetadataBearer {}
-
-/**
- * <p>
- *             The
- *             <code>CreateQualificationType</code>
- *             operation creates a new Qualification type, which is represented by a
- *             <code>QualificationType</code>
- *             data structure.
- *         </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MTurkClient, CreateQualificationTypeCommand } from "@aws-sdk/client-mturk"; // ES Modules import
- * // const { MTurkClient, CreateQualificationTypeCommand } = require("@aws-sdk/client-mturk"); // CommonJS import
- * const client = new MTurkClient(config);
- * const command = new CreateQualificationTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateQualificationTypeCommandInput} for command's `input` shape.
- * @see {@link CreateQualificationTypeCommandOutput} for command's `response` shape.
- * @see {@link MTurkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateQualificationTypeCommand extends $Command<
-  CreateQualificationTypeCommandInput,
-  CreateQualificationTypeCommandOutput,
-  MTurkClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateQualificationTypeCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MTurkClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateQualificationTypeCommandInput, CreateQualificationTypeCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MTurkClient";
-    const commandName = "CreateQualificationTypeCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateQualificationTypeRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateQualificationTypeResponse.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateQualificationTypeCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1CreateQualificationTypeCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateQualificationTypeCommandOutput> {
-    return deserializeAws_json1_1CreateQualificationTypeCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}