MTurkClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/mturk-requester/MTurkPaginationBase.h>
#include <aws/mturk-requester/MTurkServiceClientModel.h>
#include <aws/mturk-requester/MTurkWaiter.h>
#include <aws/mturk-requester/MTurk_EXPORTS.h>
 
namespace Aws {
namespace MTurk {
class AWS_MTURK_API MTurkClient : public Aws::Client::AWSJsonClient,
                                  public Aws::Client::ClientWithAsyncTemplateMethods<MTurkClient>,
                                  public MTurkPaginationBase<MTurkClient>,
                                  public MTurkWaiter<MTurkClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef MTurkClientConfiguration ClientConfigurationType;
  typedef MTurkEndpointProvider EndpointProviderType;
 
  MTurkClient(const Aws::MTurk::MTurkClientConfiguration& clientConfiguration = Aws::MTurk::MTurkClientConfiguration(),
              std::shared_ptr<MTurkEndpointProviderBase> endpointProvider = nullptr);
 
  MTurkClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<MTurkEndpointProviderBase> endpointProvider = nullptr,
              const Aws::MTurk::MTurkClientConfiguration& clientConfiguration = Aws::MTurk::MTurkClientConfiguration());
 
  MTurkClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              std::shared_ptr<MTurkEndpointProviderBase> endpointProvider = nullptr,
              const Aws::MTurk::MTurkClientConfiguration& clientConfiguration = Aws::MTurk::MTurkClientConfiguration());
 
  /* Legacy constructors due deprecation */
  MTurkClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MTurkClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MTurkClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~MTurkClient();
 
  virtual Model::AcceptQualificationRequestOutcome AcceptQualificationRequest(
      const Model::AcceptQualificationRequestRequest& request) const;
 
  template <typename AcceptQualificationRequestRequestT = Model::AcceptQualificationRequestRequest>
  Model::AcceptQualificationRequestOutcomeCallable AcceptQualificationRequestCallable(
      const AcceptQualificationRequestRequestT& request) const {
    return SubmitCallable(&MTurkClient::AcceptQualificationRequest, request);
  }
 
  template <typename AcceptQualificationRequestRequestT = Model::AcceptQualificationRequestRequest>
  void AcceptQualificationRequestAsync(const AcceptQualificationRequestRequestT& request,
                                       const AcceptQualificationRequestResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::AcceptQualificationRequest, request, handler, context);
  }
 
  virtual Model::ApproveAssignmentOutcome ApproveAssignment(const Model::ApproveAssignmentRequest& request) const;
 
  template <typename ApproveAssignmentRequestT = Model::ApproveAssignmentRequest>
  Model::ApproveAssignmentOutcomeCallable ApproveAssignmentCallable(const ApproveAssignmentRequestT& request) const {
    return SubmitCallable(&MTurkClient::ApproveAssignment, request);
  }
 
  template <typename ApproveAssignmentRequestT = Model::ApproveAssignmentRequest>
  void ApproveAssignmentAsync(const ApproveAssignmentRequestT& request, const ApproveAssignmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::ApproveAssignment, request, handler, context);
  }
 
  virtual Model::AssociateQualificationWithWorkerOutcome AssociateQualificationWithWorker(
      const Model::AssociateQualificationWithWorkerRequest& request) const;
 
  template <typename AssociateQualificationWithWorkerRequestT = Model::AssociateQualificationWithWorkerRequest>
  Model::AssociateQualificationWithWorkerOutcomeCallable AssociateQualificationWithWorkerCallable(
      const AssociateQualificationWithWorkerRequestT& request) const {
    return SubmitCallable(&MTurkClient::AssociateQualificationWithWorker, request);
  }
 
  template <typename AssociateQualificationWithWorkerRequestT = Model::AssociateQualificationWithWorkerRequest>
  void AssociateQualificationWithWorkerAsync(const AssociateQualificationWithWorkerRequestT& request,
                                             const AssociateQualificationWithWorkerResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::AssociateQualificationWithWorker, request, handler, context);
  }
 
  virtual Model::CreateAdditionalAssignmentsForHITOutcome CreateAdditionalAssignmentsForHIT(
      const Model::CreateAdditionalAssignmentsForHITRequest& request) const;
 
  template <typename CreateAdditionalAssignmentsForHITRequestT = Model::CreateAdditionalAssignmentsForHITRequest>
  Model::CreateAdditionalAssignmentsForHITOutcomeCallable CreateAdditionalAssignmentsForHITCallable(
      const CreateAdditionalAssignmentsForHITRequestT& request) const {
    return SubmitCallable(&MTurkClient::CreateAdditionalAssignmentsForHIT, request);
  }
 
  template <typename CreateAdditionalAssignmentsForHITRequestT = Model::CreateAdditionalAssignmentsForHITRequest>
  void CreateAdditionalAssignmentsForHITAsync(const CreateAdditionalAssignmentsForHITRequestT& request,
                                              const CreateAdditionalAssignmentsForHITResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::CreateAdditionalAssignmentsForHIT, request, handler, context);
  }
 
  virtual Model::CreateHITOutcome CreateHIT(const Model::CreateHITRequest& request) const;
 
  template <typename CreateHITRequestT = Model::CreateHITRequest>
  Model::CreateHITOutcomeCallable CreateHITCallable(const CreateHITRequestT& request) const {
    return SubmitCallable(&MTurkClient::CreateHIT, request);
  }
 
  template <typename CreateHITRequestT = Model::CreateHITRequest>
  void CreateHITAsync(const CreateHITRequestT& request, const CreateHITResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::CreateHIT, request, handler, context);
  }
 
  virtual Model::CreateHITTypeOutcome CreateHITType(const Model::CreateHITTypeRequest& request) const;
 
  template <typename CreateHITTypeRequestT = Model::CreateHITTypeRequest>
  Model::CreateHITTypeOutcomeCallable CreateHITTypeCallable(const CreateHITTypeRequestT& request) const {
    return SubmitCallable(&MTurkClient::CreateHITType, request);
  }
 
  template <typename CreateHITTypeRequestT = Model::CreateHITTypeRequest>
  void CreateHITTypeAsync(const CreateHITTypeRequestT& request, const CreateHITTypeResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::CreateHITType, request, handler, context);
  }
 
  virtual Model::CreateHITWithHITTypeOutcome CreateHITWithHITType(const Model::CreateHITWithHITTypeRequest& request) const;
 
  template <typename CreateHITWithHITTypeRequestT = Model::CreateHITWithHITTypeRequest>
  Model::CreateHITWithHITTypeOutcomeCallable CreateHITWithHITTypeCallable(const CreateHITWithHITTypeRequestT& request) const {
    return SubmitCallable(&MTurkClient::CreateHITWithHITType, request);
  }
 
  template <typename CreateHITWithHITTypeRequestT = Model::CreateHITWithHITTypeRequest>
  void CreateHITWithHITTypeAsync(const CreateHITWithHITTypeRequestT& request, const CreateHITWithHITTypeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::CreateHITWithHITType, request, handler, context);
  }
 
  virtual Model::CreateQualificationTypeOutcome CreateQualificationType(const Model::CreateQualificationTypeRequest& request) const;
 
  template <typename CreateQualificationTypeRequestT = Model::CreateQualificationTypeRequest>
  Model::CreateQualificationTypeOutcomeCallable CreateQualificationTypeCallable(const CreateQualificationTypeRequestT& request) const {
    return SubmitCallable(&MTurkClient::CreateQualificationType, request);
  }
 
  template <typename CreateQualificationTypeRequestT = Model::CreateQualificationTypeRequest>
  void CreateQualificationTypeAsync(const CreateQualificationTypeRequestT& request,
                                    const CreateQualificationTypeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::CreateQualificationType, request, handler, context);
  }
 
  virtual Model::CreateWorkerBlockOutcome CreateWorkerBlock(const Model::CreateWorkerBlockRequest& request) const;
 
  template <typename CreateWorkerBlockRequestT = Model::CreateWorkerBlockRequest>
  Model::CreateWorkerBlockOutcomeCallable CreateWorkerBlockCallable(const CreateWorkerBlockRequestT& request) const {
    return SubmitCallable(&MTurkClient::CreateWorkerBlock, request);
  }
 
  template <typename CreateWorkerBlockRequestT = Model::CreateWorkerBlockRequest>
  void CreateWorkerBlockAsync(const CreateWorkerBlockRequestT& request, const CreateWorkerBlockResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::CreateWorkerBlock, request, handler, context);
  }
 
  virtual Model::DeleteHITOutcome DeleteHIT(const Model::DeleteHITRequest& request) const;
 
  template <typename DeleteHITRequestT = Model::DeleteHITRequest>
  Model::DeleteHITOutcomeCallable DeleteHITCallable(const DeleteHITRequestT& request) const {
    return SubmitCallable(&MTurkClient::DeleteHIT, request);
  }
 
  template <typename DeleteHITRequestT = Model::DeleteHITRequest>
  void DeleteHITAsync(const DeleteHITRequestT& request, const DeleteHITResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::DeleteHIT, request, handler, context);
  }
 
  virtual Model::DeleteQualificationTypeOutcome DeleteQualificationType(const Model::DeleteQualificationTypeRequest& request) const;
 
  template <typename DeleteQualificationTypeRequestT = Model::DeleteQualificationTypeRequest>
  Model::DeleteQualificationTypeOutcomeCallable DeleteQualificationTypeCallable(const DeleteQualificationTypeRequestT& request) const {
    return SubmitCallable(&MTurkClient::DeleteQualificationType, request);
  }
 
  template <typename DeleteQualificationTypeRequestT = Model::DeleteQualificationTypeRequest>
  void DeleteQualificationTypeAsync(const DeleteQualificationTypeRequestT& request,
                                    const DeleteQualificationTypeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::DeleteQualificationType, request, handler, context);
  }
 
  virtual Model::DeleteWorkerBlockOutcome DeleteWorkerBlock(const Model::DeleteWorkerBlockRequest& request) const;
 
  template <typename DeleteWorkerBlockRequestT = Model::DeleteWorkerBlockRequest>
  Model::DeleteWorkerBlockOutcomeCallable DeleteWorkerBlockCallable(const DeleteWorkerBlockRequestT& request) const {
    return SubmitCallable(&MTurkClient::DeleteWorkerBlock, request);
  }
 
  template <typename DeleteWorkerBlockRequestT = Model::DeleteWorkerBlockRequest>
  void DeleteWorkerBlockAsync(const DeleteWorkerBlockRequestT& request, const DeleteWorkerBlockResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::DeleteWorkerBlock, request, handler, context);
  }
 
  virtual Model::DisassociateQualificationFromWorkerOutcome DisassociateQualificationFromWorker(
      const Model::DisassociateQualificationFromWorkerRequest& request) const;
 
  template <typename DisassociateQualificationFromWorkerRequestT = Model::DisassociateQualificationFromWorkerRequest>
  Model::DisassociateQualificationFromWorkerOutcomeCallable DisassociateQualificationFromWorkerCallable(
      const DisassociateQualificationFromWorkerRequestT& request) const {
    return SubmitCallable(&MTurkClient::DisassociateQualificationFromWorker, request);
  }
 
  template <typename DisassociateQualificationFromWorkerRequestT = Model::DisassociateQualificationFromWorkerRequest>
  void DisassociateQualificationFromWorkerAsync(const DisassociateQualificationFromWorkerRequestT& request,
                                                const DisassociateQualificationFromWorkerResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::DisassociateQualificationFromWorker, request, handler, context);
  }
 
  virtual Model::GetAccountBalanceOutcome GetAccountBalance(const Model::GetAccountBalanceRequest& request = {}) const;
 
  template <typename GetAccountBalanceRequestT = Model::GetAccountBalanceRequest>
  Model::GetAccountBalanceOutcomeCallable GetAccountBalanceCallable(const GetAccountBalanceRequestT& request = {}) const {
    return SubmitCallable(&MTurkClient::GetAccountBalance, request);
  }
 
  template <typename GetAccountBalanceRequestT = Model::GetAccountBalanceRequest>
  void GetAccountBalanceAsync(const GetAccountBalanceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const GetAccountBalanceRequestT& request = {}) const {
    return SubmitAsync(&MTurkClient::GetAccountBalance, request, handler, context);
  }
 
  virtual Model::GetAssignmentOutcome GetAssignment(const Model::GetAssignmentRequest& request) const;
 
  template <typename GetAssignmentRequestT = Model::GetAssignmentRequest>
  Model::GetAssignmentOutcomeCallable GetAssignmentCallable(const GetAssignmentRequestT& request) const {
    return SubmitCallable(&MTurkClient::GetAssignment, request);
  }
 
  template <typename GetAssignmentRequestT = Model::GetAssignmentRequest>
  void GetAssignmentAsync(const GetAssignmentRequestT& request, const GetAssignmentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::GetAssignment, request, handler, context);
  }
 
  virtual Model::GetFileUploadURLOutcome GetFileUploadURL(const Model::GetFileUploadURLRequest& request) const;
 
  template <typename GetFileUploadURLRequestT = Model::GetFileUploadURLRequest>
  Model::GetFileUploadURLOutcomeCallable GetFileUploadURLCallable(const GetFileUploadURLRequestT& request) const {
    return SubmitCallable(&MTurkClient::GetFileUploadURL, request);
  }
 
  template <typename GetFileUploadURLRequestT = Model::GetFileUploadURLRequest>
  void GetFileUploadURLAsync(const GetFileUploadURLRequestT& request, const GetFileUploadURLResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::GetFileUploadURL, request, handler, context);
  }
 
  virtual Model::GetHITOutcome GetHIT(const Model::GetHITRequest& request) const;
 
  template <typename GetHITRequestT = Model::GetHITRequest>
  Model::GetHITOutcomeCallable GetHITCallable(const GetHITRequestT& request) const {
    return SubmitCallable(&MTurkClient::GetHIT, request);
  }
 
  template <typename GetHITRequestT = Model::GetHITRequest>
  void GetHITAsync(const GetHITRequestT& request, const GetHITResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::GetHIT, request, handler, context);
  }
 
  virtual Model::GetQualificationScoreOutcome GetQualificationScore(const Model::GetQualificationScoreRequest& request) const;
 
  template <typename GetQualificationScoreRequestT = Model::GetQualificationScoreRequest>
  Model::GetQualificationScoreOutcomeCallable GetQualificationScoreCallable(const GetQualificationScoreRequestT& request) const {
    return SubmitCallable(&MTurkClient::GetQualificationScore, request);
  }
 
  template <typename GetQualificationScoreRequestT = Model::GetQualificationScoreRequest>
  void GetQualificationScoreAsync(const GetQualificationScoreRequestT& request, const GetQualificationScoreResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::GetQualificationScore, request, handler, context);
  }
 
  virtual Model::GetQualificationTypeOutcome GetQualificationType(const Model::GetQualificationTypeRequest& request) const;
 
  template <typename GetQualificationTypeRequestT = Model::GetQualificationTypeRequest>
  Model::GetQualificationTypeOutcomeCallable GetQualificationTypeCallable(const GetQualificationTypeRequestT& request) const {
    return SubmitCallable(&MTurkClient::GetQualificationType, request);
  }
 
  template <typename GetQualificationTypeRequestT = Model::GetQualificationTypeRequest>
  void GetQualificationTypeAsync(const GetQualificationTypeRequestT& request, const GetQualificationTypeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::GetQualificationType, request, handler, context);
  }
 
  virtual Model::ListAssignmentsForHITOutcome ListAssignmentsForHIT(const Model::ListAssignmentsForHITRequest& request) const;
 
  template <typename ListAssignmentsForHITRequestT = Model::ListAssignmentsForHITRequest>
  Model::ListAssignmentsForHITOutcomeCallable ListAssignmentsForHITCallable(const ListAssignmentsForHITRequestT& request) const {
    return SubmitCallable(&MTurkClient::ListAssignmentsForHIT, request);
  }
 
  template <typename ListAssignmentsForHITRequestT = Model::ListAssignmentsForHITRequest>
  void ListAssignmentsForHITAsync(const ListAssignmentsForHITRequestT& request, const ListAssignmentsForHITResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::ListAssignmentsForHIT, request, handler, context);
  }
 
  virtual Model::ListBonusPaymentsOutcome ListBonusPayments(const Model::ListBonusPaymentsRequest& request = {}) const;
 
  template <typename ListBonusPaymentsRequestT = Model::ListBonusPaymentsRequest>
  Model::ListBonusPaymentsOutcomeCallable ListBonusPaymentsCallable(const ListBonusPaymentsRequestT& request = {}) const {
    return SubmitCallable(&MTurkClient::ListBonusPayments, request);
  }
 
  template <typename ListBonusPaymentsRequestT = Model::ListBonusPaymentsRequest>
  void ListBonusPaymentsAsync(const ListBonusPaymentsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListBonusPaymentsRequestT& request = {}) const {
    return SubmitAsync(&MTurkClient::ListBonusPayments, request, handler, context);
  }
 
  virtual Model::ListHITsOutcome ListHITs(const Model::ListHITsRequest& request = {}) const;
 
  template <typename ListHITsRequestT = Model::ListHITsRequest>
  Model::ListHITsOutcomeCallable ListHITsCallable(const ListHITsRequestT& request = {}) const {
    return SubmitCallable(&MTurkClient::ListHITs, request);
  }
 
  template <typename ListHITsRequestT = Model::ListHITsRequest>
  void ListHITsAsync(const ListHITsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListHITsRequestT& request = {}) const {
    return SubmitAsync(&MTurkClient::ListHITs, request, handler, context);
  }
 
  virtual Model::ListHITsForQualificationTypeOutcome ListHITsForQualificationType(
      const Model::ListHITsForQualificationTypeRequest& request) const;
 
  template <typename ListHITsForQualificationTypeRequestT = Model::ListHITsForQualificationTypeRequest>
  Model::ListHITsForQualificationTypeOutcomeCallable ListHITsForQualificationTypeCallable(
      const ListHITsForQualificationTypeRequestT& request) const {
    return SubmitCallable(&MTurkClient::ListHITsForQualificationType, request);
  }
 
  template <typename ListHITsForQualificationTypeRequestT = Model::ListHITsForQualificationTypeRequest>
  void ListHITsForQualificationTypeAsync(const ListHITsForQualificationTypeRequestT& request,
                                         const ListHITsForQualificationTypeResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::ListHITsForQualificationType, request, handler, context);
  }
 
  virtual Model::ListQualificationRequestsOutcome ListQualificationRequests(
      const Model::ListQualificationRequestsRequest& request = {}) const;
 
  template <typename ListQualificationRequestsRequestT = Model::ListQualificationRequestsRequest>
  Model::ListQualificationRequestsOutcomeCallable ListQualificationRequestsCallable(
      const ListQualificationRequestsRequestT& request = {}) const {
    return SubmitCallable(&MTurkClient::ListQualificationRequests, request);
  }
 
  template <typename ListQualificationRequestsRequestT = Model::ListQualificationRequestsRequest>
  void ListQualificationRequestsAsync(const ListQualificationRequestsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListQualificationRequestsRequestT& request = {}) const {
    return SubmitAsync(&MTurkClient::ListQualificationRequests, request, handler, context);
  }
 
  virtual Model::ListQualificationTypesOutcome ListQualificationTypes(const Model::ListQualificationTypesRequest& request) const;
 
  template <typename ListQualificationTypesRequestT = Model::ListQualificationTypesRequest>
  Model::ListQualificationTypesOutcomeCallable ListQualificationTypesCallable(const ListQualificationTypesRequestT& request) const {
    return SubmitCallable(&MTurkClient::ListQualificationTypes, request);
  }
 
  template <typename ListQualificationTypesRequestT = Model::ListQualificationTypesRequest>
  void ListQualificationTypesAsync(const ListQualificationTypesRequestT& request,
                                   const ListQualificationTypesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::ListQualificationTypes, request, handler, context);
  }
 
  virtual Model::ListReviewPolicyResultsForHITOutcome ListReviewPolicyResultsForHIT(
      const Model::ListReviewPolicyResultsForHITRequest& request) const;
 
  template <typename ListReviewPolicyResultsForHITRequestT = Model::ListReviewPolicyResultsForHITRequest>
  Model::ListReviewPolicyResultsForHITOutcomeCallable ListReviewPolicyResultsForHITCallable(
      const ListReviewPolicyResultsForHITRequestT& request) const {
    return SubmitCallable(&MTurkClient::ListReviewPolicyResultsForHIT, request);
  }
 
  template <typename ListReviewPolicyResultsForHITRequestT = Model::ListReviewPolicyResultsForHITRequest>
  void ListReviewPolicyResultsForHITAsync(const ListReviewPolicyResultsForHITRequestT& request,
                                          const ListReviewPolicyResultsForHITResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::ListReviewPolicyResultsForHIT, request, handler, context);
  }
 
  virtual Model::ListReviewableHITsOutcome ListReviewableHITs(const Model::ListReviewableHITsRequest& request = {}) const;
 
  template <typename ListReviewableHITsRequestT = Model::ListReviewableHITsRequest>
  Model::ListReviewableHITsOutcomeCallable ListReviewableHITsCallable(const ListReviewableHITsRequestT& request = {}) const {
    return SubmitCallable(&MTurkClient::ListReviewableHITs, request);
  }
 
  template <typename ListReviewableHITsRequestT = Model::ListReviewableHITsRequest>
  void ListReviewableHITsAsync(const ListReviewableHITsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListReviewableHITsRequestT& request = {}) const {
    return SubmitAsync(&MTurkClient::ListReviewableHITs, request, handler, context);
  }
 
  virtual Model::ListWorkerBlocksOutcome ListWorkerBlocks(const Model::ListWorkerBlocksRequest& request = {}) const;
 
  template <typename ListWorkerBlocksRequestT = Model::ListWorkerBlocksRequest>
  Model::ListWorkerBlocksOutcomeCallable ListWorkerBlocksCallable(const ListWorkerBlocksRequestT& request = {}) const {
    return SubmitCallable(&MTurkClient::ListWorkerBlocks, request);
  }
 
  template <typename ListWorkerBlocksRequestT = Model::ListWorkerBlocksRequest>
  void ListWorkerBlocksAsync(const ListWorkerBlocksResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListWorkerBlocksRequestT& request = {}) const {
    return SubmitAsync(&MTurkClient::ListWorkerBlocks, request, handler, context);
  }
 
  virtual Model::ListWorkersWithQualificationTypeOutcome ListWorkersWithQualificationType(
      const Model::ListWorkersWithQualificationTypeRequest& request) const;
 
  template <typename ListWorkersWithQualificationTypeRequestT = Model::ListWorkersWithQualificationTypeRequest>
  Model::ListWorkersWithQualificationTypeOutcomeCallable ListWorkersWithQualificationTypeCallable(
      const ListWorkersWithQualificationTypeRequestT& request) const {
    return SubmitCallable(&MTurkClient::ListWorkersWithQualificationType, request);
  }
 
  template <typename ListWorkersWithQualificationTypeRequestT = Model::ListWorkersWithQualificationTypeRequest>
  void ListWorkersWithQualificationTypeAsync(const ListWorkersWithQualificationTypeRequestT& request,
                                             const ListWorkersWithQualificationTypeResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::ListWorkersWithQualificationType, request, handler, context);
  }
 
  virtual Model::NotifyWorkersOutcome NotifyWorkers(const Model::NotifyWorkersRequest& request) const;
 
  template <typename NotifyWorkersRequestT = Model::NotifyWorkersRequest>
  Model::NotifyWorkersOutcomeCallable NotifyWorkersCallable(const NotifyWorkersRequestT& request) const {
    return SubmitCallable(&MTurkClient::NotifyWorkers, request);
  }
 
  template <typename NotifyWorkersRequestT = Model::NotifyWorkersRequest>
  void NotifyWorkersAsync(const NotifyWorkersRequestT& request, const NotifyWorkersResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::NotifyWorkers, request, handler, context);
  }
 
  virtual Model::RejectAssignmentOutcome RejectAssignment(const Model::RejectAssignmentRequest& request) const;
 
  template <typename RejectAssignmentRequestT = Model::RejectAssignmentRequest>
  Model::RejectAssignmentOutcomeCallable RejectAssignmentCallable(const RejectAssignmentRequestT& request) const {
    return SubmitCallable(&MTurkClient::RejectAssignment, request);
  }
 
  template <typename RejectAssignmentRequestT = Model::RejectAssignmentRequest>
  void RejectAssignmentAsync(const RejectAssignmentRequestT& request, const RejectAssignmentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::RejectAssignment, request, handler, context);
  }
 
  virtual Model::RejectQualificationRequestOutcome RejectQualificationRequest(
      const Model::RejectQualificationRequestRequest& request) const;
 
  template <typename RejectQualificationRequestRequestT = Model::RejectQualificationRequestRequest>
  Model::RejectQualificationRequestOutcomeCallable RejectQualificationRequestCallable(
      const RejectQualificationRequestRequestT& request) const {
    return SubmitCallable(&MTurkClient::RejectQualificationRequest, request);
  }
 
  template <typename RejectQualificationRequestRequestT = Model::RejectQualificationRequestRequest>
  void RejectQualificationRequestAsync(const RejectQualificationRequestRequestT& request,
                                       const RejectQualificationRequestResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::RejectQualificationRequest, request, handler, context);
  }
 
  virtual Model::SendBonusOutcome SendBonus(const Model::SendBonusRequest& request) const;
 
  template <typename SendBonusRequestT = Model::SendBonusRequest>
  Model::SendBonusOutcomeCallable SendBonusCallable(const SendBonusRequestT& request) const {
    return SubmitCallable(&MTurkClient::SendBonus, request);
  }
 
  template <typename SendBonusRequestT = Model::SendBonusRequest>
  void SendBonusAsync(const SendBonusRequestT& request, const SendBonusResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::SendBonus, request, handler, context);
  }
 
  virtual Model::SendTestEventNotificationOutcome SendTestEventNotification(const Model::SendTestEventNotificationRequest& request) const;
 
  template <typename SendTestEventNotificationRequestT = Model::SendTestEventNotificationRequest>
  Model::SendTestEventNotificationOutcomeCallable SendTestEventNotificationCallable(
      const SendTestEventNotificationRequestT& request) const {
    return SubmitCallable(&MTurkClient::SendTestEventNotification, request);
  }
 
  template <typename SendTestEventNotificationRequestT = Model::SendTestEventNotificationRequest>
  void SendTestEventNotificationAsync(const SendTestEventNotificationRequestT& request,
                                      const SendTestEventNotificationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::SendTestEventNotification, request, handler, context);
  }
 
  virtual Model::UpdateExpirationForHITOutcome UpdateExpirationForHIT(const Model::UpdateExpirationForHITRequest& request) const;
 
  template <typename UpdateExpirationForHITRequestT = Model::UpdateExpirationForHITRequest>
  Model::UpdateExpirationForHITOutcomeCallable UpdateExpirationForHITCallable(const UpdateExpirationForHITRequestT& request) const {
    return SubmitCallable(&MTurkClient::UpdateExpirationForHIT, request);
  }
 
  template <typename UpdateExpirationForHITRequestT = Model::UpdateExpirationForHITRequest>
  void UpdateExpirationForHITAsync(const UpdateExpirationForHITRequestT& request,
                                   const UpdateExpirationForHITResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::UpdateExpirationForHIT, request, handler, context);
  }
 
  virtual Model::UpdateHITReviewStatusOutcome UpdateHITReviewStatus(const Model::UpdateHITReviewStatusRequest& request) const;
 
  template <typename UpdateHITReviewStatusRequestT = Model::UpdateHITReviewStatusRequest>
  Model::UpdateHITReviewStatusOutcomeCallable UpdateHITReviewStatusCallable(const UpdateHITReviewStatusRequestT& request) const {
    return SubmitCallable(&MTurkClient::UpdateHITReviewStatus, request);
  }
 
  template <typename UpdateHITReviewStatusRequestT = Model::UpdateHITReviewStatusRequest>
  void UpdateHITReviewStatusAsync(const UpdateHITReviewStatusRequestT& request, const UpdateHITReviewStatusResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::UpdateHITReviewStatus, request, handler, context);
  }
 
  virtual Model::UpdateHITTypeOfHITOutcome UpdateHITTypeOfHIT(const Model::UpdateHITTypeOfHITRequest& request) const;
 
  template <typename UpdateHITTypeOfHITRequestT = Model::UpdateHITTypeOfHITRequest>
  Model::UpdateHITTypeOfHITOutcomeCallable UpdateHITTypeOfHITCallable(const UpdateHITTypeOfHITRequestT& request) const {
    return SubmitCallable(&MTurkClient::UpdateHITTypeOfHIT, request);
  }
 
  template <typename UpdateHITTypeOfHITRequestT = Model::UpdateHITTypeOfHITRequest>
  void UpdateHITTypeOfHITAsync(const UpdateHITTypeOfHITRequestT& request, const UpdateHITTypeOfHITResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::UpdateHITTypeOfHIT, request, handler, context);
  }
 
  virtual Model::UpdateNotificationSettingsOutcome UpdateNotificationSettings(
      const Model::UpdateNotificationSettingsRequest& request) const;
 
  template <typename UpdateNotificationSettingsRequestT = Model::UpdateNotificationSettingsRequest>
  Model::UpdateNotificationSettingsOutcomeCallable UpdateNotificationSettingsCallable(
      const UpdateNotificationSettingsRequestT& request) const {
    return SubmitCallable(&MTurkClient::UpdateNotificationSettings, request);
  }
 
  template <typename UpdateNotificationSettingsRequestT = Model::UpdateNotificationSettingsRequest>
  void UpdateNotificationSettingsAsync(const UpdateNotificationSettingsRequestT& request,
                                       const UpdateNotificationSettingsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::UpdateNotificationSettings, request, handler, context);
  }
 
  virtual Model::UpdateQualificationTypeOutcome UpdateQualificationType(const Model::UpdateQualificationTypeRequest& request) const;
 
  template <typename UpdateQualificationTypeRequestT = Model::UpdateQualificationTypeRequest>
  Model::UpdateQualificationTypeOutcomeCallable UpdateQualificationTypeCallable(const UpdateQualificationTypeRequestT& request) const {
    return SubmitCallable(&MTurkClient::UpdateQualificationType, request);
  }
 
  template <typename UpdateQualificationTypeRequestT = Model::UpdateQualificationTypeRequest>
  void UpdateQualificationTypeAsync(const UpdateQualificationTypeRequestT& request,
                                    const UpdateQualificationTypeResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MTurkClient::UpdateQualificationType, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<MTurkEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MTurkClient>;
  void init(const MTurkClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, MTurkError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  MTurkClientConfiguration m_clientConfiguration;
  std::shared_ptr<MTurkEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace MTurk
}  // namespace Aws