@aws-sdk/client-mturk 3.35.0 → 3.38.0

package/dist-types/ts3.4/MTurkClient.d.ts

@@ -48,124 +48,59 @@ import { UpdateQualificationTypeCommandInput, UpdateQualificationTypeCommandOutp
 export declare type ServiceInputTypes = AcceptQualificationRequestCommandInput | ApproveAssignmentCommandInput | AssociateQualificationWithWorkerCommandInput | CreateAdditionalAssignmentsForHITCommandInput | CreateHITCommandInput | CreateHITTypeCommandInput | CreateHITWithHITTypeCommandInput | CreateQualificationTypeCommandInput | CreateWorkerBlockCommandInput | DeleteHITCommandInput | DeleteQualificationTypeCommandInput | DeleteWorkerBlockCommandInput | DisassociateQualificationFromWorkerCommandInput | GetAccountBalanceCommandInput | GetAssignmentCommandInput | GetFileUploadURLCommandInput | GetHITCommandInput | GetQualificationScoreCommandInput | GetQualificationTypeCommandInput | ListAssignmentsForHITCommandInput | ListBonusPaymentsCommandInput | ListHITsCommandInput | ListHITsForQualificationTypeCommandInput | ListQualificationRequestsCommandInput | ListQualificationTypesCommandInput | ListReviewPolicyResultsForHITCommandInput | ListReviewableHITsCommandInput | ListWorkerBlocksCommandInput | ListWorkersWithQualificationTypeCommandInput | NotifyWorkersCommandInput | RejectAssignmentCommandInput | RejectQualificationRequestCommandInput | SendBonusCommandInput | SendTestEventNotificationCommandInput | UpdateExpirationForHITCommandInput | UpdateHITReviewStatusCommandInput | UpdateHITTypeOfHITCommandInput | UpdateNotificationSettingsCommandInput | UpdateQualificationTypeCommandInput;
 export declare type ServiceOutputTypes = AcceptQualificationRequestCommandOutput | ApproveAssignmentCommandOutput | AssociateQualificationWithWorkerCommandOutput | CreateAdditionalAssignmentsForHITCommandOutput | CreateHITCommandOutput | CreateHITTypeCommandOutput | CreateHITWithHITTypeCommandOutput | CreateQualificationTypeCommandOutput | CreateWorkerBlockCommandOutput | DeleteHITCommandOutput | DeleteQualificationTypeCommandOutput | DeleteWorkerBlockCommandOutput | DisassociateQualificationFromWorkerCommandOutput | GetAccountBalanceCommandOutput | GetAssignmentCommandOutput | GetFileUploadURLCommandOutput | GetHITCommandOutput | GetQualificationScoreCommandOutput | GetQualificationTypeCommandOutput | ListAssignmentsForHITCommandOutput | ListBonusPaymentsCommandOutput | ListHITsCommandOutput | ListHITsForQualificationTypeCommandOutput | ListQualificationRequestsCommandOutput | ListQualificationTypesCommandOutput | ListReviewPolicyResultsForHITCommandOutput | ListReviewableHITsCommandOutput | ListWorkerBlocksCommandOutput | ListWorkersWithQualificationTypeCommandOutput | NotifyWorkersCommandOutput | RejectAssignmentCommandOutput | RejectQualificationRequestCommandOutput | SendBonusCommandOutput | SendTestEventNotificationCommandOutput | UpdateExpirationForHITCommandOutput | UpdateHITReviewStatusCommandOutput | UpdateHITTypeOfHITCommandOutput | UpdateNotificationSettingsCommandOutput | UpdateQualificationTypeCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type MTurkClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of MTurkClient class constructor that set the region, credentials and other options.
- */
+
 export interface MTurkClientConfig extends MTurkClientConfigType {
 }
 declare type MTurkClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of MTurkClient class. This is resolved and normalized from the {@link MTurkClientConfig | constructor configuration interface}.
- */
+
 export interface MTurkClientResolvedConfig extends MTurkClientResolvedConfigType {
 }
-/**
- * <fullname>Amazon Mechanical Turk API Reference</fullname>
- */
+
 export declare class MTurkClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, MTurkClientResolvedConfig> {
-    /**
-     * The resolved configuration of MTurkClient class. This is resolved and normalized from the {@link MTurkClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: MTurkClientResolvedConfig;
     constructor(configuration: MTurkClientConfig);
-    /**
-     * 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(): void;
 }
 export {};

package/dist-types/ts3.4/commands/AcceptQualificationRequestCommand.d.ts

@@ -6,38 +6,11 @@ export interface AcceptQualificationRequestCommandInput extends AcceptQualificat
 }
 export interface AcceptQualificationRequestCommandOutput extends AcceptQualificationRequestResponse, __MetadataBearer {
 }
-/**
- * <p>
- *             The <code>AcceptQualificationRequest</code> operation approves a Worker's request for a Qualification.
- *         </p>
- *         <p>
- *             Only the owner of the Qualification type can grant a Qualification request for that	type.
- *         </p>
- *         <p>
- *             A successful request for the <code>AcceptQualificationRequest</code> operation
- *             returns with no errors and an empty body.
- *         </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MTurkClient, AcceptQualificationRequestCommand } from "@aws-sdk/client-mturk"; // ES Modules import
- * // const { MTurkClient, AcceptQualificationRequestCommand } = require("@aws-sdk/client-mturk"); // CommonJS import
- * const client = new MTurkClient(config);
- * const command = new AcceptQualificationRequestCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AcceptQualificationRequestCommandInput} for command's `input` shape.
- * @see {@link AcceptQualificationRequestCommandOutput} for command's `response` shape.
- * @see {@link MTurkClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AcceptQualificationRequestCommand extends $Command<AcceptQualificationRequestCommandInput, AcceptQualificationRequestCommandOutput, MTurkClientResolvedConfig> {
     readonly input: AcceptQualificationRequestCommandInput;
     constructor(input: AcceptQualificationRequestCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MTurkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AcceptQualificationRequestCommandInput, AcceptQualificationRequestCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/ApproveAssignmentCommand.d.ts

@@ -6,58 +6,11 @@ export interface ApproveAssignmentCommandInput extends ApproveAssignmentRequest
 }
 export interface ApproveAssignmentCommandOutput extends ApproveAssignmentResponse, __MetadataBearer {
 }
-/**
- * <p>
- *             The <code>ApproveAssignment</code> operation approves the results of a completed assignment.
- *         </p>
- *         <p>
- *             Approving an assignment initiates two payments from the Requester's Amazon.com account
- *         </p>
- *         <ul>
- *             <li>
- *                 <p>
- *                     The Worker who submitted the results is paid the reward specified in the HIT.
- *                 </p>
- *             </li>
- *             <li>
- *                 <p>
- *                     Amazon Mechanical Turk fees are debited.
- *                 </p>
- *             </li>
- *          </ul>
- *         <p>
- *             If the Requester's account does not have adequate funds for these payments,
- *             the call to ApproveAssignment returns an exception, and the approval is not processed.
- *             You can include an optional feedback message with the approval,
- *             which the Worker can see in the Status section of the web site.
- *         </p>
- *         <p>
- *             You can also call this operation for assignments that were previous rejected
- *             and approve them by explicitly overriding the previous rejection.
- *             This only works on rejected assignments that were submitted within the previous 30 days
- *             and only if the assignment's related HIT has not been deleted.
- *         </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MTurkClient, ApproveAssignmentCommand } from "@aws-sdk/client-mturk"; // ES Modules import
- * // const { MTurkClient, ApproveAssignmentCommand } = require("@aws-sdk/client-mturk"); // CommonJS import
- * const client = new MTurkClient(config);
- * const command = new ApproveAssignmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ApproveAssignmentCommandInput} for command's `input` shape.
- * @see {@link ApproveAssignmentCommandOutput} for command's `response` shape.
- * @see {@link MTurkClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ApproveAssignmentCommand extends $Command<ApproveAssignmentCommandInput, ApproveAssignmentCommandOutput, MTurkClientResolvedConfig> {
     readonly input: ApproveAssignmentCommandInput;
     constructor(input: ApproveAssignmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MTurkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ApproveAssignmentCommandInput, ApproveAssignmentCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/AssociateQualificationWithWorkerCommand.d.ts

@@ -6,49 +6,11 @@ export interface AssociateQualificationWithWorkerCommandInput extends AssociateQ
 }
 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 declare class AssociateQualificationWithWorkerCommand extends $Command<AssociateQualificationWithWorkerCommandInput, AssociateQualificationWithWorkerCommandOutput, MTurkClientResolvedConfig> {
     readonly input: AssociateQualificationWithWorkerCommandInput;
     constructor(input: AssociateQualificationWithWorkerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MTurkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateQualificationWithWorkerCommandInput, AssociateQualificationWithWorkerCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateAdditionalAssignmentsForHITCommand.d.ts

@@ -6,51 +6,11 @@ export interface CreateAdditionalAssignmentsForHITCommandInput extends CreateAdd
 }
 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 declare class CreateAdditionalAssignmentsForHITCommand extends $Command<CreateAdditionalAssignmentsForHITCommandInput, CreateAdditionalAssignmentsForHITCommandOutput, MTurkClientResolvedConfig> {
     readonly input: CreateAdditionalAssignmentsForHITCommandInput;
     constructor(input: CreateAdditionalAssignmentsForHITCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MTurkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAdditionalAssignmentsForHITCommandInput, CreateAdditionalAssignmentsForHITCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateHITCommand.d.ts

@@ -6,45 +6,11 @@ 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 declare class CreateHITCommand extends $Command<CreateHITCommandInput, CreateHITCommandOutput, MTurkClientResolvedConfig> {
     readonly input: CreateHITCommandInput;
     constructor(input: CreateHITCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MTurkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateHITCommandInput, CreateHITCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateHITTypeCommand.d.ts

@@ -6,34 +6,11 @@ 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 declare class CreateHITTypeCommand extends $Command<CreateHITTypeCommandInput, CreateHITTypeCommandOutput, MTurkClientResolvedConfig> {
     readonly input: CreateHITTypeCommandInput;
     constructor(input: CreateHITTypeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MTurkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateHITTypeCommandInput, CreateHITTypeCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateHITWithHITTypeCommand.d.ts

@@ -6,46 +6,11 @@ export interface CreateHITWithHITTypeCommandInput extends CreateHITWithHITTypeRe
 }
 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 declare class CreateHITWithHITTypeCommand extends $Command<CreateHITWithHITTypeCommandInput, CreateHITWithHITTypeCommandOutput, MTurkClientResolvedConfig> {
     readonly input: CreateHITWithHITTypeCommandInput;
     constructor(input: CreateHITWithHITTypeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MTurkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateHITWithHITTypeCommandInput, CreateHITWithHITTypeCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateQualificationTypeCommand.d.ts

@@ -6,35 +6,11 @@ export interface CreateQualificationTypeCommandInput extends CreateQualification
 }
 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 declare class CreateQualificationTypeCommand extends $Command<CreateQualificationTypeCommandInput, CreateQualificationTypeCommandOutput, MTurkClientResolvedConfig> {
     readonly input: CreateQualificationTypeCommandInput;
     constructor(input: CreateQualificationTypeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MTurkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateQualificationTypeCommandInput, CreateQualificationTypeCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateWorkerBlockCommand.d.ts

@@ -6,29 +6,11 @@ export interface CreateWorkerBlockCommandInput extends CreateWorkerBlockRequest
 }
 export interface CreateWorkerBlockCommandOutput extends CreateWorkerBlockResponse, __MetadataBearer {
 }
-/**
- * <p>The <code>CreateWorkerBlock</code> operation allows you to prevent a Worker from working on your HITs. For example, you can block a Worker who is producing poor quality work. You can block up to 100,000 Workers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MTurkClient, CreateWorkerBlockCommand } from "@aws-sdk/client-mturk"; // ES Modules import
- * // const { MTurkClient, CreateWorkerBlockCommand } = require("@aws-sdk/client-mturk"); // CommonJS import
- * const client = new MTurkClient(config);
- * const command = new CreateWorkerBlockCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateWorkerBlockCommandInput} for command's `input` shape.
- * @see {@link CreateWorkerBlockCommandOutput} for command's `response` shape.
- * @see {@link MTurkClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateWorkerBlockCommand extends $Command<CreateWorkerBlockCommandInput, CreateWorkerBlockCommandOutput, MTurkClientResolvedConfig> {
     readonly input: CreateWorkerBlockCommandInput;
     constructor(input: CreateWorkerBlockCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MTurkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateWorkerBlockCommandInput, CreateWorkerBlockCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteHITCommand.d.ts

@@ -6,64 +6,11 @@ export interface DeleteHITCommandInput extends DeleteHITRequest {
 }
 export interface DeleteHITCommandOutput extends DeleteHITResponse, __MetadataBearer {
 }
-/**
- * <p>
- *             The <code>DeleteHIT</code> operation is used to delete HIT that is no longer needed.
- *             Only the Requester who created the HIT can delete it.
- *         </p>
- *         <p>
- *             You can only dispose of HITs that are in the <code>Reviewable</code> state,
- *             with all of their submitted assignments already either approved or rejected.
- *             If you call the DeleteHIT operation on a HIT that is not in the <code>Reviewable</code> state
- *             (for example, that has not expired, or still has active assignments),
- *             or on a HIT that is Reviewable but without all of its submitted assignments
- *             already approved or rejected, the service will return an error.
- *         </p>
- *         <note>
- *             <ul>
- *                <li>
- *                     <p>
- *                         HITs are automatically disposed of after 120 days.
- *                     </p>
- *                 </li>
- *                <li>
- *                     <p>
- *                         After you dispose of a HIT, you can no longer approve the HIT's rejected assignments.
- *                     </p>
- *                 </li>
- *                <li>
- *                     <p>
- *                         Disposed HITs are not returned in results for the ListHITs operation.
- *                     </p>
- *                 </li>
- *                <li>
- *                     <p>
- *                         Disposing HITs can improve the performance of operations such as ListReviewableHITs and ListHITs.
- *                     </p>
- *                 </li>
- *             </ul>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MTurkClient, DeleteHITCommand } from "@aws-sdk/client-mturk"; // ES Modules import
- * // const { MTurkClient, DeleteHITCommand } = require("@aws-sdk/client-mturk"); // CommonJS import
- * const client = new MTurkClient(config);
- * const command = new DeleteHITCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteHITCommandInput} for command's `input` shape.
- * @see {@link DeleteHITCommandOutput} for command's `response` shape.
- * @see {@link MTurkClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteHITCommand extends $Command<DeleteHITCommandInput, DeleteHITCommandOutput, MTurkClientResolvedConfig> {
     readonly input: DeleteHITCommandInput;
     constructor(input: DeleteHITCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MTurkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteHITCommandInput, DeleteHITCommandOutput>;
     private serialize;
     private deserialize;