MTurkClient.h

 
#pragma once
#include <aws/mturk-requester/MTurk_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/mturk-requester/MTurkServiceClientModel.h>
 
namespace Aws
{
namespace MTurk
{
  class AWS_MTURK_API MTurkClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MTurkEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MTurkClient>;
      void init(const MTurkClientConfiguration& clientConfiguration);
 
      MTurkClientConfiguration m_clientConfiguration;
      std::shared_ptr<MTurkEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MTurk
} // namespace Aws