/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the mturk-requester-2017-01-17.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.MTurk.Model; using Amazon.MTurk.Model.Internal.MarshallTransformations; using Amazon.MTurk.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.MTurk { ///

/// Implementation for accessing MTurk /// /// Amazon Mechanical Turk API Reference ///

public partial class AmazonMTurkClient : AmazonServiceClient, IAmazonMTurk { private static IServiceMetadata serviceMetadata = new AmazonMTurkMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private IMTurkPaginatorFactory _paginators; ///

/// Paginators for the service ///

public IMTurkPaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new MTurkPaginatorFactory(this); } return this._paginators; } } #endif #region Constructors ///

/// Constructs AmazonMTurkClient with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonMTurkClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonMTurkConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonMTurkClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonMTurkConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonMTurkClient Configuration Object public AmazonMTurkClient(AmazonMTurkConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonMTurkClient with AWS Credentials ///

/// AWS Credentials public AmazonMTurkClient(AWSCredentials credentials) : this(credentials, new AmazonMTurkConfig()) { } ///

/// Constructs AmazonMTurkClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonMTurkClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonMTurkConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonMTurkClient with AWS Credentials and an /// AmazonMTurkClient Configuration object. ///

/// AWS Credentials /// The AmazonMTurkClient Configuration Object public AmazonMTurkClient(AWSCredentials credentials, AmazonMTurkConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonMTurkClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonMTurkClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonMTurkConfig()) { } ///

/// Constructs AmazonMTurkClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonMTurkClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonMTurkConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonMTurkClient with AWS Access Key ID, AWS Secret Key and an /// AmazonMTurkClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonMTurkClient Configuration Object public AmazonMTurkClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonMTurkConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonMTurkClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonMTurkClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonMTurkConfig()) { } ///

/// Constructs AmazonMTurkClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonMTurkClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonMTurkConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonMTurkClient with AWS Access Key ID, AWS Secret Key and an /// AmazonMTurkClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonMTurkClient Configuration Object public AmazonMTurkClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonMTurkConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customize the pipeline ///

/// protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonMTurkEndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #region AcceptQualificationRequest ///

/// The AcceptQualificationRequest operation approves a Worker's request /// for a Qualification. /// /// /// /// Only the owner of the Qualification type can grant a Qualification request for that /// type. /// /// /// /// A successful request for the AcceptQualificationRequest operation returns /// with no errors and an empty body. /// ///

/// Container for the necessary parameters to execute the AcceptQualificationRequest service method. /// /// The response from the AcceptQualificationRequest service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for AcceptQualificationRequest Operation public virtual AcceptQualificationRequestResponse AcceptQualificationRequest(AcceptQualificationRequestRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptQualificationRequestRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptQualificationRequestResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AcceptQualificationRequest operation. ///

/// /// Container for the necessary parameters to execute the AcceptQualificationRequest operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAcceptQualificationRequest /// operation. /// REST API Reference for AcceptQualificationRequest Operation public virtual IAsyncResult BeginAcceptQualificationRequest(AcceptQualificationRequestRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptQualificationRequestRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptQualificationRequestResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AcceptQualificationRequest operation. ///

/// /// The IAsyncResult returned by the call to BeginAcceptQualificationRequest. /// /// Returns a AcceptQualificationRequestResult from MTurk. /// REST API Reference for AcceptQualificationRequest Operation public virtual AcceptQualificationRequestResponse EndAcceptQualificationRequest(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ApproveAssignment ///

/// The ApproveAssignment operation approves the results of a completed /// assignment. /// /// /// /// Approving an assignment initiates two payments from the Requester's Amazon.com account /// /// ///

/// /// The Worker who submitted the results is paid the reward specified in the HIT. /// ///
/// /// Amazon Mechanical Turk fees are debited. /// ///

/// /// 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. /// /// /// /// 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. /// ///

/// Container for the necessary parameters to execute the ApproveAssignment service method. /// /// The response from the ApproveAssignment service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ApproveAssignment Operation public virtual ApproveAssignmentResponse ApproveAssignment(ApproveAssignmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ApproveAssignmentRequestMarshaller.Instance; options.ResponseUnmarshaller = ApproveAssignmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ApproveAssignment operation. ///

/// /// Container for the necessary parameters to execute the ApproveAssignment operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndApproveAssignment /// operation. /// REST API Reference for ApproveAssignment Operation public virtual IAsyncResult BeginApproveAssignment(ApproveAssignmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ApproveAssignmentRequestMarshaller.Instance; options.ResponseUnmarshaller = ApproveAssignmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ApproveAssignment operation. ///

/// /// The IAsyncResult returned by the call to BeginApproveAssignment. /// /// Returns a ApproveAssignmentResult from MTurk. /// REST API Reference for ApproveAssignment Operation public virtual ApproveAssignmentResponse EndApproveAssignment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AssociateQualificationWithWorker ///

/// The AssociateQualificationWithWorker operation gives a Worker a Qualification. /// AssociateQualificationWithWorker does not require that the Worker submit /// a Qualification request. It gives the Qualification directly to the Worker. /// /// /// /// You can only assign a Qualification of a Qualification type that you created (using /// the CreateQualificationType operation). /// /// /// /// Note: AssociateQualificationWithWorker 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 RejectQualificationRequest /// operation. /// /// ///

/// Container for the necessary parameters to execute the AssociateQualificationWithWorker service method. /// /// The response from the AssociateQualificationWithWorker service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for AssociateQualificationWithWorker Operation public virtual AssociateQualificationWithWorkerResponse AssociateQualificationWithWorker(AssociateQualificationWithWorkerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateQualificationWithWorkerRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateQualificationWithWorkerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AssociateQualificationWithWorker operation. ///

/// /// Container for the necessary parameters to execute the AssociateQualificationWithWorker operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAssociateQualificationWithWorker /// operation. /// REST API Reference for AssociateQualificationWithWorker Operation public virtual IAsyncResult BeginAssociateQualificationWithWorker(AssociateQualificationWithWorkerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AssociateQualificationWithWorkerRequestMarshaller.Instance; options.ResponseUnmarshaller = AssociateQualificationWithWorkerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AssociateQualificationWithWorker operation. ///

/// /// The IAsyncResult returned by the call to BeginAssociateQualificationWithWorker. /// /// Returns a AssociateQualificationWithWorkerResult from MTurk. /// REST API Reference for AssociateQualificationWithWorker Operation public virtual AssociateQualificationWithWorkerResponse EndAssociateQualificationWithWorker(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateAdditionalAssignmentsForHIT ///

/// The CreateAdditionalAssignmentsForHIT operation increases the maximum /// number of assignments of an existing HIT. /// /// /// /// To extend the maximum number of assignments, specify the number of additional assignments. /// ///

/// /// 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 AWS.MechanicalTurk.InvalidMaximumAssignmentsIncrease exception. /// ///
/// /// 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 AWS.MechanicalTurk.HITTooOldForExtension /// exception. /// ///

///

/// Container for the necessary parameters to execute the CreateAdditionalAssignmentsForHIT service method. /// /// The response from the CreateAdditionalAssignmentsForHIT service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for CreateAdditionalAssignmentsForHIT Operation public virtual CreateAdditionalAssignmentsForHITResponse CreateAdditionalAssignmentsForHIT(CreateAdditionalAssignmentsForHITRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAdditionalAssignmentsForHITRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAdditionalAssignmentsForHITResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateAdditionalAssignmentsForHIT operation. ///

/// /// Container for the necessary parameters to execute the CreateAdditionalAssignmentsForHIT operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateAdditionalAssignmentsForHIT /// operation. /// REST API Reference for CreateAdditionalAssignmentsForHIT Operation public virtual IAsyncResult BeginCreateAdditionalAssignmentsForHIT(CreateAdditionalAssignmentsForHITRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAdditionalAssignmentsForHITRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAdditionalAssignmentsForHITResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateAdditionalAssignmentsForHIT operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateAdditionalAssignmentsForHIT. /// /// Returns a CreateAdditionalAssignmentsForHITResult from MTurk. /// REST API Reference for CreateAdditionalAssignmentsForHIT Operation public virtual CreateAdditionalAssignmentsForHITResponse EndCreateAdditionalAssignmentsForHIT(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateHIT ///

/// The CreateHIT 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. /// /// /// /// 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 CreateHIT, a new HIT is created for you, with a new HITTypeID. /// 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. /// /// /// /// An alternative way to create HITs is to first generate a HITTypeID using the CreateHITType /// operation and then call the CreateHITWithHITType operation. This is the /// recommended best practice for Requesters who are creating large numbers of HITs. /// /// /// /// CreateHIT also supports several ways to provide question data: by providing a value /// for the Question parameter that fully specifies the contents of the HIT, /// or by providing a HitLayoutId and associated HitLayoutParameters. /// /// /// /// /// If a HIT is created with 10 or more maximum assignments, there is an additional fee. /// For more information, see Amazon Mechanical /// Turk Pricing. /// /// ///

/// Container for the necessary parameters to execute the CreateHIT service method. /// /// The response from the CreateHIT service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for CreateHIT Operation public virtual CreateHITResponse CreateHIT(CreateHITRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateHITRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateHITResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateHIT operation. ///

/// /// Container for the necessary parameters to execute the CreateHIT operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateHIT /// operation. /// REST API Reference for CreateHIT Operation public virtual IAsyncResult BeginCreateHIT(CreateHITRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateHITRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateHITResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateHIT operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateHIT. /// /// Returns a CreateHITResult from MTurk. /// REST API Reference for CreateHIT Operation public virtual CreateHITResponse EndCreateHIT(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateHITType ///

/// The CreateHITType 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. ///

/// Container for the necessary parameters to execute the CreateHITType service method. /// /// The response from the CreateHITType service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for CreateHITType Operation public virtual CreateHITTypeResponse CreateHITType(CreateHITTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateHITTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateHITTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateHITType operation. ///

/// /// Container for the necessary parameters to execute the CreateHITType operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateHITType /// operation. /// REST API Reference for CreateHITType Operation public virtual IAsyncResult BeginCreateHITType(CreateHITTypeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateHITTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateHITTypeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateHITType operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateHITType. /// /// Returns a CreateHITTypeResult from MTurk. /// REST API Reference for CreateHITType Operation public virtual CreateHITTypeResponse EndCreateHITType(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateHITWithHITType ///

/// The CreateHITWithHITType operation creates a new Human Intelligence /// Task (HIT) using an existing HITTypeID generated by the CreateHITType /// operation. /// /// /// /// This is an alternative way to create HITs from the CreateHIT operation. /// This is the recommended best practice for Requesters who are creating large numbers /// of HITs. /// /// /// /// CreateHITWithHITType also supports several ways to provide question data: by providing /// a value for the Question parameter that fully specifies the contents /// of the HIT, or by providing a HitLayoutId and associated HitLayoutParameters. /// /// /// /// /// If a HIT is created with 10 or more maximum assignments, there is an additional fee. /// For more information, see Amazon Mechanical /// Turk Pricing. /// /// ///

/// Container for the necessary parameters to execute the CreateHITWithHITType service method. /// /// The response from the CreateHITWithHITType service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for CreateHITWithHITType Operation public virtual CreateHITWithHITTypeResponse CreateHITWithHITType(CreateHITWithHITTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateHITWithHITTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateHITWithHITTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateHITWithHITType operation. ///

/// /// Container for the necessary parameters to execute the CreateHITWithHITType operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateHITWithHITType /// operation. /// REST API Reference for CreateHITWithHITType Operation public virtual IAsyncResult BeginCreateHITWithHITType(CreateHITWithHITTypeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateHITWithHITTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateHITWithHITTypeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateHITWithHITType operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateHITWithHITType. /// /// Returns a CreateHITWithHITTypeResult from MTurk. /// REST API Reference for CreateHITWithHITType Operation public virtual CreateHITWithHITTypeResponse EndCreateHITWithHITType(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateQualificationType ///

/// The CreateQualificationType operation creates a new Qualification type, /// which is represented by a QualificationType data structure. ///

/// Container for the necessary parameters to execute the CreateQualificationType service method. /// /// The response from the CreateQualificationType service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for CreateQualificationType Operation public virtual CreateQualificationTypeResponse CreateQualificationType(CreateQualificationTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateQualificationTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateQualificationType operation. ///

/// /// Container for the necessary parameters to execute the CreateQualificationType operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateQualificationType /// operation. /// REST API Reference for CreateQualificationType Operation public virtual IAsyncResult BeginCreateQualificationType(CreateQualificationTypeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateQualificationTypeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateQualificationType operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateQualificationType. /// /// Returns a CreateQualificationTypeResult from MTurk. /// REST API Reference for CreateQualificationType Operation public virtual CreateQualificationTypeResponse EndCreateQualificationType(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateWorkerBlock ///

/// The CreateWorkerBlock 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. ///

/// Container for the necessary parameters to execute the CreateWorkerBlock service method. /// /// The response from the CreateWorkerBlock service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for CreateWorkerBlock Operation public virtual CreateWorkerBlockResponse CreateWorkerBlock(CreateWorkerBlockRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkerBlockRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkerBlockResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateWorkerBlock operation. ///

/// /// Container for the necessary parameters to execute the CreateWorkerBlock operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateWorkerBlock /// operation. /// REST API Reference for CreateWorkerBlock Operation public virtual IAsyncResult BeginCreateWorkerBlock(CreateWorkerBlockRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkerBlockRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkerBlockResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateWorkerBlock operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateWorkerBlock. /// /// Returns a CreateWorkerBlockResult from MTurk. /// REST API Reference for CreateWorkerBlock Operation public virtual CreateWorkerBlockResponse EndCreateWorkerBlock(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteHIT ///

/// The DeleteHIT operation is used to delete HIT that is no longer needed. /// Only the Requester who created the HIT can delete it. /// /// /// /// You can only dispose of HITs that are in the Reviewable 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 Reviewable 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. /// ///

/// /// HITs are automatically disposed of after 120 days. /// ///
/// /// After you dispose of a HIT, you can no longer approve the HIT's rejected assignments. /// /// ///
/// /// Disposed HITs are not returned in results for the ListHITs operation. /// ///
/// /// Disposing HITs can improve the performance of operations such as ListReviewableHITs /// and ListHITs. /// ///

///

/// Container for the necessary parameters to execute the DeleteHIT service method. /// /// The response from the DeleteHIT service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for DeleteHIT Operation public virtual DeleteHITResponse DeleteHIT(DeleteHITRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteHITRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteHITResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteHIT operation. ///

/// /// Container for the necessary parameters to execute the DeleteHIT operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteHIT /// operation. /// REST API Reference for DeleteHIT Operation public virtual IAsyncResult BeginDeleteHIT(DeleteHITRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteHITRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteHITResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteHIT operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteHIT. /// /// Returns a DeleteHITResult from MTurk. /// REST API Reference for DeleteHIT Operation public virtual DeleteHITResponse EndDeleteHIT(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteQualificationType ///

/// The DeleteQualificationType deletes a Qualification type and deletes /// any HIT types that are associated with the Qualification type. /// /// /// /// This operation does not revoke Qualifications already assigned to Workers because /// the Qualifications might be needed for active HITs. If there are any pending requests /// for the Qualification type, Amazon Mechanical Turk rejects those requests. After you /// delete a Qualification type, you can no longer use it to create HITs or HIT types. /// /// /// /// DeleteQualificationType must wait for all the HITs that use the deleted Qualification /// type to be deleted before completing. It may take up to 48 hours before DeleteQualificationType /// completes and the unique name of the Qualification type is available for reuse with /// CreateQualificationType. /// /// ///

/// Container for the necessary parameters to execute the DeleteQualificationType service method. /// /// The response from the DeleteQualificationType service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for DeleteQualificationType Operation public virtual DeleteQualificationTypeResponse DeleteQualificationType(DeleteQualificationTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteQualificationTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteQualificationType operation. ///

/// /// Container for the necessary parameters to execute the DeleteQualificationType operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteQualificationType /// operation. /// REST API Reference for DeleteQualificationType Operation public virtual IAsyncResult BeginDeleteQualificationType(DeleteQualificationTypeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteQualificationTypeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteQualificationType operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteQualificationType. /// /// Returns a DeleteQualificationTypeResult from MTurk. /// REST API Reference for DeleteQualificationType Operation public virtual DeleteQualificationTypeResponse EndDeleteQualificationType(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteWorkerBlock ///

/// The DeleteWorkerBlock operation allows you to reinstate a blocked Worker /// to work on your HITs. This operation reverses the effects of the CreateWorkerBlock /// operation. You need the Worker ID to use this operation. If the Worker ID is missing /// or invalid, this operation fails and returns the message “WorkerId is invalid.” If /// the specified Worker is not blocked, this operation returns successfully. ///

/// Container for the necessary parameters to execute the DeleteWorkerBlock service method. /// /// The response from the DeleteWorkerBlock service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for DeleteWorkerBlock Operation public virtual DeleteWorkerBlockResponse DeleteWorkerBlock(DeleteWorkerBlockRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkerBlockRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkerBlockResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteWorkerBlock operation. ///

/// /// Container for the necessary parameters to execute the DeleteWorkerBlock operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteWorkerBlock /// operation. /// REST API Reference for DeleteWorkerBlock Operation public virtual IAsyncResult BeginDeleteWorkerBlock(DeleteWorkerBlockRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkerBlockRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkerBlockResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteWorkerBlock operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteWorkerBlock. /// /// Returns a DeleteWorkerBlockResult from MTurk. /// REST API Reference for DeleteWorkerBlock Operation public virtual DeleteWorkerBlockResponse EndDeleteWorkerBlock(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisassociateQualificationFromWorker ///

/// The DisassociateQualificationFromWorker revokes a previously granted /// Qualification from a user. /// /// /// /// You can provide a text message explaining why the Qualification was revoked. The /// user who had the Qualification can see this message. /// ///

/// Container for the necessary parameters to execute the DisassociateQualificationFromWorker service method. /// /// The response from the DisassociateQualificationFromWorker service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for DisassociateQualificationFromWorker Operation public virtual DisassociateQualificationFromWorkerResponse DisassociateQualificationFromWorker(DisassociateQualificationFromWorkerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateQualificationFromWorkerRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateQualificationFromWorkerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DisassociateQualificationFromWorker operation. ///

/// /// Container for the necessary parameters to execute the DisassociateQualificationFromWorker operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisassociateQualificationFromWorker /// operation. /// REST API Reference for DisassociateQualificationFromWorker Operation public virtual IAsyncResult BeginDisassociateQualificationFromWorker(DisassociateQualificationFromWorkerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DisassociateQualificationFromWorkerRequestMarshaller.Instance; options.ResponseUnmarshaller = DisassociateQualificationFromWorkerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DisassociateQualificationFromWorker operation. ///

/// /// The IAsyncResult returned by the call to BeginDisassociateQualificationFromWorker. /// /// Returns a DisassociateQualificationFromWorkerResult from MTurk. /// REST API Reference for DisassociateQualificationFromWorker Operation public virtual DisassociateQualificationFromWorkerResponse EndDisassociateQualificationFromWorker(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetAccountBalance ///

/// The GetAccountBalance operation retrieves the Prepaid HITs balance in /// your Amazon Mechanical Turk account if you are a Prepaid Requester. Alternatively, /// this operation will retrieve the remaining available AWS Billing usage if you have /// enabled AWS Billing. Note: If you have enabled AWS Billing and still have a remaining /// Prepaid HITs balance, this balance can be viewed on the My Account page in the Requester /// console. ///

/// Container for the necessary parameters to execute the GetAccountBalance service method. /// /// The response from the GetAccountBalance service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for GetAccountBalance Operation public virtual GetAccountBalanceResponse GetAccountBalance(GetAccountBalanceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAccountBalanceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAccountBalanceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetAccountBalance operation. ///

/// /// Container for the necessary parameters to execute the GetAccountBalance operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAccountBalance /// operation. /// REST API Reference for GetAccountBalance Operation public virtual IAsyncResult BeginGetAccountBalance(GetAccountBalanceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetAccountBalanceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAccountBalanceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetAccountBalance operation. ///

/// /// The IAsyncResult returned by the call to BeginGetAccountBalance. /// /// Returns a GetAccountBalanceResult from MTurk. /// REST API Reference for GetAccountBalance Operation public virtual GetAccountBalanceResponse EndGetAccountBalance(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetAssignment ///

/// The GetAssignment operation retrieves the details of the specified Assignment. ///

/// Container for the necessary parameters to execute the GetAssignment service method. /// /// The response from the GetAssignment service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for GetAssignment Operation public virtual GetAssignmentResponse GetAssignment(GetAssignmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetAssignmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAssignmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetAssignment operation. ///

/// /// Container for the necessary parameters to execute the GetAssignment operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetAssignment /// operation. /// REST API Reference for GetAssignment Operation public virtual IAsyncResult BeginGetAssignment(GetAssignmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetAssignmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetAssignmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetAssignment operation. ///

/// /// The IAsyncResult returned by the call to BeginGetAssignment. /// /// Returns a GetAssignmentResult from MTurk. /// REST API Reference for GetAssignment Operation public virtual GetAssignmentResponse EndGetAssignment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetFileUploadURL ///

/// The GetFileUploadURL operation generates and returns a temporary URL. /// You use the temporary URL to retrieve a file uploaded by a Worker as an answer to /// a FileUploadAnswer question for a HIT. The temporary URL is generated the instant /// the GetFileUploadURL operation is called, and is valid for 60 seconds. You can get /// a temporary file upload URL any time until the HIT is disposed. After the HIT is disposed, /// any uploaded files are deleted, and cannot be retrieved. Pending Deprecation on December /// 12, 2017. The Answer Specification structure will no longer support the FileUploadAnswer /// element to be used for the QuestionForm data structure. Instead, we recommend that /// Requesters who want to create HITs asking Workers to upload files to use Amazon S3. ///

/// Container for the necessary parameters to execute the GetFileUploadURL service method. /// /// The response from the GetFileUploadURL service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for GetFileUploadURL Operation public virtual GetFileUploadURLResponse GetFileUploadURL(GetFileUploadURLRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetFileUploadURLRequestMarshaller.Instance; options.ResponseUnmarshaller = GetFileUploadURLResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetFileUploadURL operation. ///

/// /// Container for the necessary parameters to execute the GetFileUploadURL operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetFileUploadURL /// operation. /// REST API Reference for GetFileUploadURL Operation public virtual IAsyncResult BeginGetFileUploadURL(GetFileUploadURLRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetFileUploadURLRequestMarshaller.Instance; options.ResponseUnmarshaller = GetFileUploadURLResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetFileUploadURL operation. ///

/// /// The IAsyncResult returned by the call to BeginGetFileUploadURL. /// /// Returns a GetFileUploadURLResult from MTurk. /// REST API Reference for GetFileUploadURL Operation public virtual GetFileUploadURLResponse EndGetFileUploadURL(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetHIT ///

/// The GetHIT operation retrieves the details of the specified HIT. ///

/// Container for the necessary parameters to execute the GetHIT service method. /// /// The response from the GetHIT service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for GetHIT Operation public virtual GetHITResponse GetHIT(GetHITRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetHITRequestMarshaller.Instance; options.ResponseUnmarshaller = GetHITResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetHIT operation. ///

/// /// Container for the necessary parameters to execute the GetHIT operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetHIT /// operation. /// REST API Reference for GetHIT Operation public virtual IAsyncResult BeginGetHIT(GetHITRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetHITRequestMarshaller.Instance; options.ResponseUnmarshaller = GetHITResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetHIT operation. ///

/// /// The IAsyncResult returned by the call to BeginGetHIT. /// /// Returns a GetHITResult from MTurk. /// REST API Reference for GetHIT Operation public virtual GetHITResponse EndGetHIT(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetQualificationScore ///

/// The GetQualificationScore operation returns the value of a Worker's /// Qualification for a given Qualification type. /// /// /// /// To get a Worker's Qualification, you must know the Worker's ID. The Worker's ID is /// included in the assignment data returned by the ListAssignmentsForHIT /// operation. /// /// /// /// Only the owner of a Qualification type can query the value of a Worker's Qualification /// of that type. /// ///

/// Container for the necessary parameters to execute the GetQualificationScore service method. /// /// The response from the GetQualificationScore service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for GetQualificationScore Operation public virtual GetQualificationScoreResponse GetQualificationScore(GetQualificationScoreRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetQualificationScoreRequestMarshaller.Instance; options.ResponseUnmarshaller = GetQualificationScoreResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetQualificationScore operation. ///

/// /// Container for the necessary parameters to execute the GetQualificationScore operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetQualificationScore /// operation. /// REST API Reference for GetQualificationScore Operation public virtual IAsyncResult BeginGetQualificationScore(GetQualificationScoreRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetQualificationScoreRequestMarshaller.Instance; options.ResponseUnmarshaller = GetQualificationScoreResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetQualificationScore operation. ///

/// /// The IAsyncResult returned by the call to BeginGetQualificationScore. /// /// Returns a GetQualificationScoreResult from MTurk. /// REST API Reference for GetQualificationScore Operation public virtual GetQualificationScoreResponse EndGetQualificationScore(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetQualificationType ///

/// The GetQualificationTypeoperation retrieves information about a Qualification /// type using its ID. ///

/// Container for the necessary parameters to execute the GetQualificationType service method. /// /// The response from the GetQualificationType service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for GetQualificationType Operation public virtual GetQualificationTypeResponse GetQualificationType(GetQualificationTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = GetQualificationTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetQualificationType operation. ///

/// /// Container for the necessary parameters to execute the GetQualificationType operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetQualificationType /// operation. /// REST API Reference for GetQualificationType Operation public virtual IAsyncResult BeginGetQualificationType(GetQualificationTypeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = GetQualificationTypeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetQualificationType operation. ///

/// /// The IAsyncResult returned by the call to BeginGetQualificationType. /// /// Returns a GetQualificationTypeResult from MTurk. /// REST API Reference for GetQualificationType Operation public virtual GetQualificationTypeResponse EndGetQualificationType(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListAssignmentsForHIT ///

/// The ListAssignmentsForHIT operation retrieves completed assignments /// for a HIT. You can use this operation to retrieve the results for a HIT. /// /// /// /// You can get assignments for a HIT at any time, even if the HIT is not yet Reviewable. /// If a HIT requested multiple assignments, and has received some results but has not /// yet become Reviewable, you can still retrieve the partial results with this operation. /// /// /// /// /// Use the AssignmentStatus parameter to control which set of assignments for a HIT /// are returned. The ListAssignmentsForHIT operation can return submitted assignments /// awaiting approval, or it can return assignments that have already been approved or /// rejected. You can set AssignmentStatus=Approved,Rejected to get assignments that have /// already been approved and rejected together in one result set. /// /// /// /// Only the Requester who created the HIT can retrieve the assignments for that HIT. /// /// /// /// /// Results are sorted and divided into numbered pages and the operation returns a single /// page of results. You can use the parameters of the operation to control sorting and /// pagination. /// ///

/// Container for the necessary parameters to execute the ListAssignmentsForHIT service method. /// /// The response from the ListAssignmentsForHIT service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ListAssignmentsForHIT Operation public virtual ListAssignmentsForHITResponse ListAssignmentsForHIT(ListAssignmentsForHITRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssignmentsForHITRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssignmentsForHITResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListAssignmentsForHIT operation. ///

/// /// Container for the necessary parameters to execute the ListAssignmentsForHIT operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListAssignmentsForHIT /// operation. /// REST API Reference for ListAssignmentsForHIT Operation public virtual IAsyncResult BeginListAssignmentsForHIT(ListAssignmentsForHITRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListAssignmentsForHITRequestMarshaller.Instance; options.ResponseUnmarshaller = ListAssignmentsForHITResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListAssignmentsForHIT operation. ///

/// /// The IAsyncResult returned by the call to BeginListAssignmentsForHIT. /// /// Returns a ListAssignmentsForHITResult from MTurk. /// REST API Reference for ListAssignmentsForHIT Operation public virtual ListAssignmentsForHITResponse EndListAssignmentsForHIT(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListBonusPayments ///

/// The ListBonusPayments operation retrieves the amounts of bonuses you /// have paid to Workers for a given HIT or assignment. ///

/// Container for the necessary parameters to execute the ListBonusPayments service method. /// /// The response from the ListBonusPayments service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ListBonusPayments Operation public virtual ListBonusPaymentsResponse ListBonusPayments(ListBonusPaymentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListBonusPaymentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListBonusPaymentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListBonusPayments operation. ///

/// /// Container for the necessary parameters to execute the ListBonusPayments operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListBonusPayments /// operation. /// REST API Reference for ListBonusPayments Operation public virtual IAsyncResult BeginListBonusPayments(ListBonusPaymentsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListBonusPaymentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListBonusPaymentsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListBonusPayments operation. ///

/// /// The IAsyncResult returned by the call to BeginListBonusPayments. /// /// Returns a ListBonusPaymentsResult from MTurk. /// REST API Reference for ListBonusPayments Operation public virtual ListBonusPaymentsResponse EndListBonusPayments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListHITs ///

/// The ListHITs operation returns all of a Requester's HITs. The operation /// returns HITs of any status, except for HITs that have been deleted of with the DeleteHIT /// operation or that have been auto-deleted. ///

/// Container for the necessary parameters to execute the ListHITs service method. /// /// The response from the ListHITs service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ListHITs Operation public virtual ListHITsResponse ListHITs(ListHITsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListHITsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListHITsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListHITs operation. ///

/// /// Container for the necessary parameters to execute the ListHITs operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListHITs /// operation. /// REST API Reference for ListHITs Operation public virtual IAsyncResult BeginListHITs(ListHITsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListHITsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListHITsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListHITs operation. ///

/// /// The IAsyncResult returned by the call to BeginListHITs. /// /// Returns a ListHITsResult from MTurk. /// REST API Reference for ListHITs Operation public virtual ListHITsResponse EndListHITs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListHITsForQualificationType ///

/// The ListHITsForQualificationType operation returns the HITs that use /// the given Qualification type for a Qualification requirement. The operation returns /// HITs of any status, except for HITs that have been deleted with the DeleteHIT /// operation or that have been auto-deleted. ///

/// Container for the necessary parameters to execute the ListHITsForQualificationType service method. /// /// The response from the ListHITsForQualificationType service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ListHITsForQualificationType Operation public virtual ListHITsForQualificationTypeResponse ListHITsForQualificationType(ListHITsForQualificationTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListHITsForQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = ListHITsForQualificationTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListHITsForQualificationType operation. ///

/// /// Container for the necessary parameters to execute the ListHITsForQualificationType operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListHITsForQualificationType /// operation. /// REST API Reference for ListHITsForQualificationType Operation public virtual IAsyncResult BeginListHITsForQualificationType(ListHITsForQualificationTypeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListHITsForQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = ListHITsForQualificationTypeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListHITsForQualificationType operation. ///

/// /// The IAsyncResult returned by the call to BeginListHITsForQualificationType. /// /// Returns a ListHITsForQualificationTypeResult from MTurk. /// REST API Reference for ListHITsForQualificationType Operation public virtual ListHITsForQualificationTypeResponse EndListHITsForQualificationType(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListQualificationRequests ///

/// The ListQualificationRequests operation retrieves requests for Qualifications /// of a particular Qualification type. The owner of the Qualification type calls this /// operation to poll for pending requests, and accepts them using the AcceptQualification /// operation. ///

/// Container for the necessary parameters to execute the ListQualificationRequests service method. /// /// The response from the ListQualificationRequests service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ListQualificationRequests Operation public virtual ListQualificationRequestsResponse ListQualificationRequests(ListQualificationRequestsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListQualificationRequestsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListQualificationRequestsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListQualificationRequests operation. ///

/// /// Container for the necessary parameters to execute the ListQualificationRequests operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListQualificationRequests /// operation. /// REST API Reference for ListQualificationRequests Operation public virtual IAsyncResult BeginListQualificationRequests(ListQualificationRequestsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListQualificationRequestsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListQualificationRequestsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListQualificationRequests operation. ///

/// /// The IAsyncResult returned by the call to BeginListQualificationRequests. /// /// Returns a ListQualificationRequestsResult from MTurk. /// REST API Reference for ListQualificationRequests Operation public virtual ListQualificationRequestsResponse EndListQualificationRequests(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListQualificationTypes ///

/// The ListQualificationTypes operation returns a list of Qualification /// types, filtered by an optional search term. ///

/// Container for the necessary parameters to execute the ListQualificationTypes service method. /// /// The response from the ListQualificationTypes service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ListQualificationTypes Operation public virtual ListQualificationTypesResponse ListQualificationTypes(ListQualificationTypesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListQualificationTypesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListQualificationTypesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListQualificationTypes operation. ///

/// /// Container for the necessary parameters to execute the ListQualificationTypes operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListQualificationTypes /// operation. /// REST API Reference for ListQualificationTypes Operation public virtual IAsyncResult BeginListQualificationTypes(ListQualificationTypesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListQualificationTypesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListQualificationTypesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListQualificationTypes operation. ///

/// /// The IAsyncResult returned by the call to BeginListQualificationTypes. /// /// Returns a ListQualificationTypesResult from MTurk. /// REST API Reference for ListQualificationTypes Operation public virtual ListQualificationTypesResponse EndListQualificationTypes(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReviewableHITs ///

/// The ListReviewableHITs operation retrieves the HITs with Status equal /// to Reviewable or Status equal to Reviewing that belong to the Requester calling the /// operation. ///

/// Container for the necessary parameters to execute the ListReviewableHITs service method. /// /// The response from the ListReviewableHITs service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ListReviewableHITs Operation public virtual ListReviewableHITsResponse ListReviewableHITs(ListReviewableHITsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReviewableHITsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReviewableHITsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListReviewableHITs operation. ///

/// /// Container for the necessary parameters to execute the ListReviewableHITs operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListReviewableHITs /// operation. /// REST API Reference for ListReviewableHITs Operation public virtual IAsyncResult BeginListReviewableHITs(ListReviewableHITsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReviewableHITsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReviewableHITsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListReviewableHITs operation. ///

/// /// The IAsyncResult returned by the call to BeginListReviewableHITs. /// /// Returns a ListReviewableHITsResult from MTurk. /// REST API Reference for ListReviewableHITs Operation public virtual ListReviewableHITsResponse EndListReviewableHITs(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListReviewPolicyResultsForHIT ///

/// The ListReviewPolicyResultsForHIT operation retrieves the computed results /// and the actions taken in the course of executing your Review Policies for a given /// HIT. For information about how to specify Review Policies when you call CreateHIT, /// see Review Policies. The ListReviewPolicyResultsForHIT operation can return results /// for both Assignment-level and HIT-level review results. ///

/// Container for the necessary parameters to execute the ListReviewPolicyResultsForHIT service method. /// /// The response from the ListReviewPolicyResultsForHIT service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ListReviewPolicyResultsForHIT Operation public virtual ListReviewPolicyResultsForHITResponse ListReviewPolicyResultsForHIT(ListReviewPolicyResultsForHITRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListReviewPolicyResultsForHITRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReviewPolicyResultsForHITResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListReviewPolicyResultsForHIT operation. ///

/// /// Container for the necessary parameters to execute the ListReviewPolicyResultsForHIT operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListReviewPolicyResultsForHIT /// operation. /// REST API Reference for ListReviewPolicyResultsForHIT Operation public virtual IAsyncResult BeginListReviewPolicyResultsForHIT(ListReviewPolicyResultsForHITRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListReviewPolicyResultsForHITRequestMarshaller.Instance; options.ResponseUnmarshaller = ListReviewPolicyResultsForHITResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListReviewPolicyResultsForHIT operation. ///

/// /// The IAsyncResult returned by the call to BeginListReviewPolicyResultsForHIT. /// /// Returns a ListReviewPolicyResultsForHITResult from MTurk. /// REST API Reference for ListReviewPolicyResultsForHIT Operation public virtual ListReviewPolicyResultsForHITResponse EndListReviewPolicyResultsForHIT(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListWorkerBlocks ///

/// The ListWorkersBlocks operation retrieves a list of Workers who are blocked /// from working on your HITs. ///

/// Container for the necessary parameters to execute the ListWorkerBlocks service method. /// /// The response from the ListWorkerBlocks service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ListWorkerBlocks Operation public virtual ListWorkerBlocksResponse ListWorkerBlocks(ListWorkerBlocksRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkerBlocksRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkerBlocksResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListWorkerBlocks operation. ///

/// /// Container for the necessary parameters to execute the ListWorkerBlocks operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListWorkerBlocks /// operation. /// REST API Reference for ListWorkerBlocks Operation public virtual IAsyncResult BeginListWorkerBlocks(ListWorkerBlocksRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkerBlocksRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkerBlocksResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListWorkerBlocks operation. ///

/// /// The IAsyncResult returned by the call to BeginListWorkerBlocks. /// /// Returns a ListWorkerBlocksResult from MTurk. /// REST API Reference for ListWorkerBlocks Operation public virtual ListWorkerBlocksResponse EndListWorkerBlocks(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListWorkersWithQualificationType ///

/// The ListWorkersWithQualificationType operation returns all of the Workers /// that have been associated with a given Qualification type. ///

/// Container for the necessary parameters to execute the ListWorkersWithQualificationType service method. /// /// The response from the ListWorkersWithQualificationType service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for ListWorkersWithQualificationType Operation public virtual ListWorkersWithQualificationTypeResponse ListWorkersWithQualificationType(ListWorkersWithQualificationTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkersWithQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkersWithQualificationTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListWorkersWithQualificationType operation. ///

/// /// Container for the necessary parameters to execute the ListWorkersWithQualificationType operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListWorkersWithQualificationType /// operation. /// REST API Reference for ListWorkersWithQualificationType Operation public virtual IAsyncResult BeginListWorkersWithQualificationType(ListWorkersWithQualificationTypeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkersWithQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkersWithQualificationTypeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListWorkersWithQualificationType operation. ///

/// /// The IAsyncResult returned by the call to BeginListWorkersWithQualificationType. /// /// Returns a ListWorkersWithQualificationTypeResult from MTurk. /// REST API Reference for ListWorkersWithQualificationType Operation public virtual ListWorkersWithQualificationTypeResponse EndListWorkersWithQualificationType(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region NotifyWorkers ///

/// The NotifyWorkers operation sends an email to one or more Workers that /// you specify with the Worker ID. You can specify up to 100 Worker IDs to send the same /// message with a single call to the NotifyWorkers operation. The NotifyWorkers operation /// will send a notification email to a Worker only if you have previously approved or /// rejected work from the Worker. ///

/// Container for the necessary parameters to execute the NotifyWorkers service method. /// /// The response from the NotifyWorkers service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for NotifyWorkers Operation public virtual NotifyWorkersResponse NotifyWorkers(NotifyWorkersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = NotifyWorkersRequestMarshaller.Instance; options.ResponseUnmarshaller = NotifyWorkersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the NotifyWorkers operation. ///

/// /// Container for the necessary parameters to execute the NotifyWorkers operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndNotifyWorkers /// operation. /// REST API Reference for NotifyWorkers Operation public virtual IAsyncResult BeginNotifyWorkers(NotifyWorkersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = NotifyWorkersRequestMarshaller.Instance; options.ResponseUnmarshaller = NotifyWorkersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the NotifyWorkers operation. ///

/// /// The IAsyncResult returned by the call to BeginNotifyWorkers. /// /// Returns a NotifyWorkersResult from MTurk. /// REST API Reference for NotifyWorkers Operation public virtual NotifyWorkersResponse EndNotifyWorkers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RejectAssignment ///

/// The RejectAssignment operation rejects the results of a completed assignment. /// /// /// /// /// You can include an optional feedback message with the rejection, which the Worker /// can see in the Status section of the web site. When you include a feedback message /// with the rejection, it helps the Worker understand why the assignment was rejected, /// and can improve the quality of the results the Worker submits in the future. /// /// /// /// Only the Requester who created the HIT can reject an assignment for the HIT. /// ///

/// Container for the necessary parameters to execute the RejectAssignment service method. /// /// The response from the RejectAssignment service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for RejectAssignment Operation public virtual RejectAssignmentResponse RejectAssignment(RejectAssignmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RejectAssignmentRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectAssignmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RejectAssignment operation. ///

/// /// Container for the necessary parameters to execute the RejectAssignment operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRejectAssignment /// operation. /// REST API Reference for RejectAssignment Operation public virtual IAsyncResult BeginRejectAssignment(RejectAssignmentRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RejectAssignmentRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectAssignmentResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RejectAssignment operation. ///

/// /// The IAsyncResult returned by the call to BeginRejectAssignment. /// /// Returns a RejectAssignmentResult from MTurk. /// REST API Reference for RejectAssignment Operation public virtual RejectAssignmentResponse EndRejectAssignment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RejectQualificationRequest ///

/// The RejectQualificationRequest operation rejects a user's request for /// a Qualification. /// /// /// /// You can provide a text message explaining why the request was rejected. The Worker /// who made the request can see this message. /// ///

/// Container for the necessary parameters to execute the RejectQualificationRequest service method. /// /// The response from the RejectQualificationRequest service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for RejectQualificationRequest Operation public virtual RejectQualificationRequestResponse RejectQualificationRequest(RejectQualificationRequestRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RejectQualificationRequestRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectQualificationRequestResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RejectQualificationRequest operation. ///

/// /// Container for the necessary parameters to execute the RejectQualificationRequest operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRejectQualificationRequest /// operation. /// REST API Reference for RejectQualificationRequest Operation public virtual IAsyncResult BeginRejectQualificationRequest(RejectQualificationRequestRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RejectQualificationRequestRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectQualificationRequestResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RejectQualificationRequest operation. ///

/// /// The IAsyncResult returned by the call to BeginRejectQualificationRequest. /// /// Returns a RejectQualificationRequestResult from MTurk. /// REST API Reference for RejectQualificationRequest Operation public virtual RejectQualificationRequestResponse EndRejectQualificationRequest(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region SendBonus ///

/// The SendBonus operation issues a payment of money from your account /// to a Worker. This payment happens separately from the reward you pay to the Worker /// when you approve the Worker's assignment. The SendBonus operation requires the Worker's /// ID and the assignment ID as parameters to initiate payment of the bonus. You must /// include a message that explains the reason for the bonus payment, as the Worker may /// not be expecting the payment. Amazon Mechanical Turk collects a fee for bonus payments, /// similar to the HIT listing fee. This operation fails if your account does not have /// enough funds to pay for both the bonus and the fees. ///

/// Container for the necessary parameters to execute the SendBonus service method. /// /// The response from the SendBonus service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for SendBonus Operation public virtual SendBonusResponse SendBonus(SendBonusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SendBonusRequestMarshaller.Instance; options.ResponseUnmarshaller = SendBonusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the SendBonus operation. ///

/// /// Container for the necessary parameters to execute the SendBonus operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSendBonus /// operation. /// REST API Reference for SendBonus Operation public virtual IAsyncResult BeginSendBonus(SendBonusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = SendBonusRequestMarshaller.Instance; options.ResponseUnmarshaller = SendBonusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the SendBonus operation. ///

/// /// The IAsyncResult returned by the call to BeginSendBonus. /// /// Returns a SendBonusResult from MTurk. /// REST API Reference for SendBonus Operation public virtual SendBonusResponse EndSendBonus(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region SendTestEventNotification ///

/// The SendTestEventNotification operation causes Amazon Mechanical Turk /// to send a notification message as if a HIT event occurred, according to the provided /// notification specification. This allows you to test notifications without setting /// up notifications for a real HIT type and trying to trigger them using the website. /// When you call this operation, the service attempts to send the test notification immediately. ///

/// Container for the necessary parameters to execute the SendTestEventNotification service method. /// /// The response from the SendTestEventNotification service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for SendTestEventNotification Operation public virtual SendTestEventNotificationResponse SendTestEventNotification(SendTestEventNotificationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = SendTestEventNotificationRequestMarshaller.Instance; options.ResponseUnmarshaller = SendTestEventNotificationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the SendTestEventNotification operation. ///

/// /// Container for the necessary parameters to execute the SendTestEventNotification operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndSendTestEventNotification /// operation. /// REST API Reference for SendTestEventNotification Operation public virtual IAsyncResult BeginSendTestEventNotification(SendTestEventNotificationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = SendTestEventNotificationRequestMarshaller.Instance; options.ResponseUnmarshaller = SendTestEventNotificationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the SendTestEventNotification operation. ///

/// /// The IAsyncResult returned by the call to BeginSendTestEventNotification. /// /// Returns a SendTestEventNotificationResult from MTurk. /// REST API Reference for SendTestEventNotification Operation public virtual SendTestEventNotificationResponse EndSendTestEventNotification(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateExpirationForHIT ///

/// The UpdateExpirationForHIT operation allows you update the expiration /// time of a HIT. If you update it to a time in the past, the HIT will be immediately /// expired. ///

/// Container for the necessary parameters to execute the UpdateExpirationForHIT service method. /// /// The response from the UpdateExpirationForHIT service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for UpdateExpirationForHIT Operation public virtual UpdateExpirationForHITResponse UpdateExpirationForHIT(UpdateExpirationForHITRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateExpirationForHITRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateExpirationForHITResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateExpirationForHIT operation. ///

/// /// Container for the necessary parameters to execute the UpdateExpirationForHIT operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateExpirationForHIT /// operation. /// REST API Reference for UpdateExpirationForHIT Operation public virtual IAsyncResult BeginUpdateExpirationForHIT(UpdateExpirationForHITRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateExpirationForHITRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateExpirationForHITResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateExpirationForHIT operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateExpirationForHIT. /// /// Returns a UpdateExpirationForHITResult from MTurk. /// REST API Reference for UpdateExpirationForHIT Operation public virtual UpdateExpirationForHITResponse EndUpdateExpirationForHIT(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateHITReviewStatus ///

/// The UpdateHITReviewStatus operation updates the status of a HIT. If /// the status is Reviewable, this operation can update the status to Reviewing, or it /// can revert a Reviewing HIT back to the Reviewable status. ///

/// Container for the necessary parameters to execute the UpdateHITReviewStatus service method. /// /// The response from the UpdateHITReviewStatus service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for UpdateHITReviewStatus Operation public virtual UpdateHITReviewStatusResponse UpdateHITReviewStatus(UpdateHITReviewStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateHITReviewStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateHITReviewStatusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateHITReviewStatus operation. ///

/// /// Container for the necessary parameters to execute the UpdateHITReviewStatus operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateHITReviewStatus /// operation. /// REST API Reference for UpdateHITReviewStatus Operation public virtual IAsyncResult BeginUpdateHITReviewStatus(UpdateHITReviewStatusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateHITReviewStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateHITReviewStatusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateHITReviewStatus operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateHITReviewStatus. /// /// Returns a UpdateHITReviewStatusResult from MTurk. /// REST API Reference for UpdateHITReviewStatus Operation public virtual UpdateHITReviewStatusResponse EndUpdateHITReviewStatus(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateHITTypeOfHIT ///

/// The UpdateHITTypeOfHIT operation allows you to change the HITType properties /// of a HIT. This operation disassociates the HIT from its old HITType properties and /// associates it with the new HITType properties. The HIT takes on the properties of /// the new HITType in place of the old ones. ///

/// Container for the necessary parameters to execute the UpdateHITTypeOfHIT service method. /// /// The response from the UpdateHITTypeOfHIT service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for UpdateHITTypeOfHIT Operation public virtual UpdateHITTypeOfHITResponse UpdateHITTypeOfHIT(UpdateHITTypeOfHITRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateHITTypeOfHITRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateHITTypeOfHITResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateHITTypeOfHIT operation. ///

/// /// Container for the necessary parameters to execute the UpdateHITTypeOfHIT operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateHITTypeOfHIT /// operation. /// REST API Reference for UpdateHITTypeOfHIT Operation public virtual IAsyncResult BeginUpdateHITTypeOfHIT(UpdateHITTypeOfHITRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateHITTypeOfHITRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateHITTypeOfHITResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateHITTypeOfHIT operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateHITTypeOfHIT. /// /// Returns a UpdateHITTypeOfHITResult from MTurk. /// REST API Reference for UpdateHITTypeOfHIT Operation public virtual UpdateHITTypeOfHITResponse EndUpdateHITTypeOfHIT(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateNotificationSettings ///

/// The UpdateNotificationSettings operation creates, updates, disables /// or re-enables notifications for a HIT type. If you call the UpdateNotificationSettings /// operation for a HIT type that already has a notification specification, the operation /// replaces the old specification with a new one. You can call the UpdateNotificationSettings /// operation to enable or disable notifications for the HIT type, without having to modify /// the notification specification itself by providing updates to the Active status without /// specifying a new notification specification. To change the Active status of a HIT /// type's notifications, the HIT type must already have a notification specification, /// or one must be provided in the same call to UpdateNotificationSettings. ///

/// Container for the necessary parameters to execute the UpdateNotificationSettings service method. /// /// The response from the UpdateNotificationSettings service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for UpdateNotificationSettings Operation public virtual UpdateNotificationSettingsResponse UpdateNotificationSettings(UpdateNotificationSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNotificationSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNotificationSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateNotificationSettings operation. ///

/// /// Container for the necessary parameters to execute the UpdateNotificationSettings operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateNotificationSettings /// operation. /// REST API Reference for UpdateNotificationSettings Operation public virtual IAsyncResult BeginUpdateNotificationSettings(UpdateNotificationSettingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNotificationSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNotificationSettingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateNotificationSettings operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateNotificationSettings. /// /// Returns a UpdateNotificationSettingsResult from MTurk. /// REST API Reference for UpdateNotificationSettings Operation public virtual UpdateNotificationSettingsResponse EndUpdateNotificationSettings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateQualificationType ///

/// The UpdateQualificationType operation modifies the attributes of an /// existing Qualification type, which is represented by a QualificationType data structure. /// Only the owner of a Qualification type can modify its attributes. /// /// /// /// Most attributes of a Qualification type can be changed after the type has been created. /// However, the Name and Keywords fields cannot be modified. The RetryDelayInSeconds /// parameter can be modified or added to change the delay or to enable retries, but RetryDelayInSeconds /// cannot be used to disable retries. /// /// /// /// You can use this operation to update the test for a Qualification type. The test /// is updated based on the values specified for the Test, TestDurationInSeconds and AnswerKey /// parameters. All three parameters specify the updated test. If you are updating the /// test for a type, you must specify the Test and TestDurationInSeconds parameters. The /// AnswerKey parameter is optional; omitting it specifies that the updated test does /// not have an answer key. /// /// /// /// If you omit the Test parameter, the test for the Qualification type is unchanged. /// There is no way to remove a test from a Qualification type that has one. If the type /// already has a test, you cannot update it to be AutoGranted. If the Qualification type /// does not have a test and one is provided by an update, the type will henceforth have /// a test. /// /// /// /// If you want to update the test duration or answer key for an existing test without /// changing the questions, you must specify a Test parameter with the original questions, /// along with the updated values. /// /// /// /// If you provide an updated Test but no AnswerKey, the new test will not have an answer /// key. Requests for such Qualifications must be granted manually. /// /// /// /// You can also update the AutoGranted and AutoGrantedValue attributes of the Qualification /// type. /// ///

/// Container for the necessary parameters to execute the UpdateQualificationType service method. /// /// The response from the UpdateQualificationType service method, as returned by MTurk. /// /// Your request is invalid. /// /// /// Amazon Mechanical Turk is temporarily unable to process your request. Try your call /// again. /// /// REST API Reference for UpdateQualificationType Operation public virtual UpdateQualificationTypeResponse UpdateQualificationType(UpdateQualificationTypeRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateQualificationTypeResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateQualificationType operation. ///

/// /// Container for the necessary parameters to execute the UpdateQualificationType operation on AmazonMTurkClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateQualificationType /// operation. /// REST API Reference for UpdateQualificationType Operation public virtual IAsyncResult BeginUpdateQualificationType(UpdateQualificationTypeRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateQualificationTypeRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateQualificationTypeResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateQualificationType operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateQualificationType. /// /// Returns a UpdateQualificationTypeResult from MTurk. /// REST API Reference for UpdateQualificationType Operation public virtual UpdateQualificationTypeResponse EndUpdateQualificationType(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }