FraudDetectorClient.h

 
#pragma once
#include <aws/frauddetector/FraudDetector_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/frauddetector/FraudDetectorServiceClientModel.h>
 
namespace Aws
{
namespace FraudDetector
{
  class AWS_FRAUDDETECTOR_API FraudDetectorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<FraudDetectorClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef FraudDetectorClientConfiguration ClientConfigurationType;
      typedef FraudDetectorEndpointProvider EndpointProviderType;
 
        FraudDetectorClient(const Aws::FraudDetector::FraudDetectorClientConfiguration& clientConfiguration = Aws::FraudDetector::FraudDetectorClientConfiguration(),
                            std::shared_ptr<FraudDetectorEndpointProviderBase> endpointProvider = nullptr);
 
        FraudDetectorClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<FraudDetectorEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::FraudDetector::FraudDetectorClientConfiguration& clientConfiguration = Aws::FraudDetector::FraudDetectorClientConfiguration());
 
        FraudDetectorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<FraudDetectorEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::FraudDetector::FraudDetectorClientConfiguration& clientConfiguration = Aws::FraudDetector::FraudDetectorClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        FraudDetectorClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        FraudDetectorClient(const Aws::Auth::AWSCredentials& credentials,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        FraudDetectorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~FraudDetectorClient();
 
        virtual Model::BatchCreateVariableOutcome BatchCreateVariable(const Model::BatchCreateVariableRequest& request) const;
 
        template<typename BatchCreateVariableRequestT = Model::BatchCreateVariableRequest>
        Model::BatchCreateVariableOutcomeCallable BatchCreateVariableCallable(const BatchCreateVariableRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::BatchCreateVariable, request);
        }
 
        template<typename BatchCreateVariableRequestT = Model::BatchCreateVariableRequest>
        void BatchCreateVariableAsync(const BatchCreateVariableRequestT& request, const BatchCreateVariableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::BatchCreateVariable, request, handler, context);
        }
 
        virtual Model::BatchGetVariableOutcome BatchGetVariable(const Model::BatchGetVariableRequest& request) const;
 
        template<typename BatchGetVariableRequestT = Model::BatchGetVariableRequest>
        Model::BatchGetVariableOutcomeCallable BatchGetVariableCallable(const BatchGetVariableRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::BatchGetVariable, request);
        }
 
        template<typename BatchGetVariableRequestT = Model::BatchGetVariableRequest>
        void BatchGetVariableAsync(const BatchGetVariableRequestT& request, const BatchGetVariableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::BatchGetVariable, request, handler, context);
        }
 
        virtual Model::CancelBatchImportJobOutcome CancelBatchImportJob(const Model::CancelBatchImportJobRequest& request) const;
 
        template<typename CancelBatchImportJobRequestT = Model::CancelBatchImportJobRequest>
        Model::CancelBatchImportJobOutcomeCallable CancelBatchImportJobCallable(const CancelBatchImportJobRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::CancelBatchImportJob, request);
        }
 
        template<typename CancelBatchImportJobRequestT = Model::CancelBatchImportJobRequest>
        void CancelBatchImportJobAsync(const CancelBatchImportJobRequestT& request, const CancelBatchImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::CancelBatchImportJob, request, handler, context);
        }
 
        virtual Model::CancelBatchPredictionJobOutcome CancelBatchPredictionJob(const Model::CancelBatchPredictionJobRequest& request) const;
 
        template<typename CancelBatchPredictionJobRequestT = Model::CancelBatchPredictionJobRequest>
        Model::CancelBatchPredictionJobOutcomeCallable CancelBatchPredictionJobCallable(const CancelBatchPredictionJobRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::CancelBatchPredictionJob, request);
        }
 
        template<typename CancelBatchPredictionJobRequestT = Model::CancelBatchPredictionJobRequest>
        void CancelBatchPredictionJobAsync(const CancelBatchPredictionJobRequestT& request, const CancelBatchPredictionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::CancelBatchPredictionJob, request, handler, context);
        }
 
        virtual Model::CreateBatchImportJobOutcome CreateBatchImportJob(const Model::CreateBatchImportJobRequest& request) const;
 
        template<typename CreateBatchImportJobRequestT = Model::CreateBatchImportJobRequest>
        Model::CreateBatchImportJobOutcomeCallable CreateBatchImportJobCallable(const CreateBatchImportJobRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::CreateBatchImportJob, request);
        }
 
        template<typename CreateBatchImportJobRequestT = Model::CreateBatchImportJobRequest>
        void CreateBatchImportJobAsync(const CreateBatchImportJobRequestT& request, const CreateBatchImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::CreateBatchImportJob, request, handler, context);
        }
 
        virtual Model::CreateBatchPredictionJobOutcome CreateBatchPredictionJob(const Model::CreateBatchPredictionJobRequest& request) const;
 
        template<typename CreateBatchPredictionJobRequestT = Model::CreateBatchPredictionJobRequest>
        Model::CreateBatchPredictionJobOutcomeCallable CreateBatchPredictionJobCallable(const CreateBatchPredictionJobRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::CreateBatchPredictionJob, request);
        }
 
        template<typename CreateBatchPredictionJobRequestT = Model::CreateBatchPredictionJobRequest>
        void CreateBatchPredictionJobAsync(const CreateBatchPredictionJobRequestT& request, const CreateBatchPredictionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::CreateBatchPredictionJob, request, handler, context);
        }
 
        virtual Model::CreateDetectorVersionOutcome CreateDetectorVersion(const Model::CreateDetectorVersionRequest& request) const;
 
        template<typename CreateDetectorVersionRequestT = Model::CreateDetectorVersionRequest>
        Model::CreateDetectorVersionOutcomeCallable CreateDetectorVersionCallable(const CreateDetectorVersionRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::CreateDetectorVersion, request);
        }
 
        template<typename CreateDetectorVersionRequestT = Model::CreateDetectorVersionRequest>
        void CreateDetectorVersionAsync(const CreateDetectorVersionRequestT& request, const CreateDetectorVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::CreateDetectorVersion, request, handler, context);
        }
 
        virtual Model::CreateListOutcome CreateList(const Model::CreateListRequest& request) const;
 
        template<typename CreateListRequestT = Model::CreateListRequest>
        Model::CreateListOutcomeCallable CreateListCallable(const CreateListRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::CreateList, request);
        }
 
        template<typename CreateListRequestT = Model::CreateListRequest>
        void CreateListAsync(const CreateListRequestT& request, const CreateListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::CreateList, request, handler, context);
        }
 
        virtual Model::CreateModelOutcome CreateModel(const Model::CreateModelRequest& request) const;
 
        template<typename CreateModelRequestT = Model::CreateModelRequest>
        Model::CreateModelOutcomeCallable CreateModelCallable(const CreateModelRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::CreateModel, request);
        }
 
        template<typename CreateModelRequestT = Model::CreateModelRequest>
        void CreateModelAsync(const CreateModelRequestT& request, const CreateModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::CreateModel, request, handler, context);
        }
 
        virtual Model::CreateModelVersionOutcome CreateModelVersion(const Model::CreateModelVersionRequest& request) const;
 
        template<typename CreateModelVersionRequestT = Model::CreateModelVersionRequest>
        Model::CreateModelVersionOutcomeCallable CreateModelVersionCallable(const CreateModelVersionRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::CreateModelVersion, request);
        }
 
        template<typename CreateModelVersionRequestT = Model::CreateModelVersionRequest>
        void CreateModelVersionAsync(const CreateModelVersionRequestT& request, const CreateModelVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::CreateModelVersion, request, handler, context);
        }
 
        virtual Model::CreateRuleOutcome CreateRule(const Model::CreateRuleRequest& request) const;
 
        template<typename CreateRuleRequestT = Model::CreateRuleRequest>
        Model::CreateRuleOutcomeCallable CreateRuleCallable(const CreateRuleRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::CreateRule, request);
        }
 
        template<typename CreateRuleRequestT = Model::CreateRuleRequest>
        void CreateRuleAsync(const CreateRuleRequestT& request, const CreateRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::CreateRule, request, handler, context);
        }
 
        virtual Model::CreateVariableOutcome CreateVariable(const Model::CreateVariableRequest& request) const;
 
        template<typename CreateVariableRequestT = Model::CreateVariableRequest>
        Model::CreateVariableOutcomeCallable CreateVariableCallable(const CreateVariableRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::CreateVariable, request);
        }
 
        template<typename CreateVariableRequestT = Model::CreateVariableRequest>
        void CreateVariableAsync(const CreateVariableRequestT& request, const CreateVariableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::CreateVariable, request, handler, context);
        }
 
        virtual Model::DeleteBatchImportJobOutcome DeleteBatchImportJob(const Model::DeleteBatchImportJobRequest& request) const;
 
        template<typename DeleteBatchImportJobRequestT = Model::DeleteBatchImportJobRequest>
        Model::DeleteBatchImportJobOutcomeCallable DeleteBatchImportJobCallable(const DeleteBatchImportJobRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteBatchImportJob, request);
        }
 
        template<typename DeleteBatchImportJobRequestT = Model::DeleteBatchImportJobRequest>
        void DeleteBatchImportJobAsync(const DeleteBatchImportJobRequestT& request, const DeleteBatchImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteBatchImportJob, request, handler, context);
        }
 
        virtual Model::DeleteBatchPredictionJobOutcome DeleteBatchPredictionJob(const Model::DeleteBatchPredictionJobRequest& request) const;
 
        template<typename DeleteBatchPredictionJobRequestT = Model::DeleteBatchPredictionJobRequest>
        Model::DeleteBatchPredictionJobOutcomeCallable DeleteBatchPredictionJobCallable(const DeleteBatchPredictionJobRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteBatchPredictionJob, request);
        }
 
        template<typename DeleteBatchPredictionJobRequestT = Model::DeleteBatchPredictionJobRequest>
        void DeleteBatchPredictionJobAsync(const DeleteBatchPredictionJobRequestT& request, const DeleteBatchPredictionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteBatchPredictionJob, request, handler, context);
        }
 
        virtual Model::DeleteDetectorOutcome DeleteDetector(const Model::DeleteDetectorRequest& request) const;
 
        template<typename DeleteDetectorRequestT = Model::DeleteDetectorRequest>
        Model::DeleteDetectorOutcomeCallable DeleteDetectorCallable(const DeleteDetectorRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteDetector, request);
        }
 
        template<typename DeleteDetectorRequestT = Model::DeleteDetectorRequest>
        void DeleteDetectorAsync(const DeleteDetectorRequestT& request, const DeleteDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteDetector, request, handler, context);
        }
 
        virtual Model::DeleteDetectorVersionOutcome DeleteDetectorVersion(const Model::DeleteDetectorVersionRequest& request) const;
 
        template<typename DeleteDetectorVersionRequestT = Model::DeleteDetectorVersionRequest>
        Model::DeleteDetectorVersionOutcomeCallable DeleteDetectorVersionCallable(const DeleteDetectorVersionRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteDetectorVersion, request);
        }
 
        template<typename DeleteDetectorVersionRequestT = Model::DeleteDetectorVersionRequest>
        void DeleteDetectorVersionAsync(const DeleteDetectorVersionRequestT& request, const DeleteDetectorVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteDetectorVersion, request, handler, context);
        }
 
        virtual Model::DeleteEntityTypeOutcome DeleteEntityType(const Model::DeleteEntityTypeRequest& request) const;
 
        template<typename DeleteEntityTypeRequestT = Model::DeleteEntityTypeRequest>
        Model::DeleteEntityTypeOutcomeCallable DeleteEntityTypeCallable(const DeleteEntityTypeRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteEntityType, request);
        }
 
        template<typename DeleteEntityTypeRequestT = Model::DeleteEntityTypeRequest>
        void DeleteEntityTypeAsync(const DeleteEntityTypeRequestT& request, const DeleteEntityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteEntityType, request, handler, context);
        }
 
        virtual Model::DeleteEventOutcome DeleteEvent(const Model::DeleteEventRequest& request) const;
 
        template<typename DeleteEventRequestT = Model::DeleteEventRequest>
        Model::DeleteEventOutcomeCallable DeleteEventCallable(const DeleteEventRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteEvent, request);
        }
 
        template<typename DeleteEventRequestT = Model::DeleteEventRequest>
        void DeleteEventAsync(const DeleteEventRequestT& request, const DeleteEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteEvent, request, handler, context);
        }
 
        virtual Model::DeleteEventTypeOutcome DeleteEventType(const Model::DeleteEventTypeRequest& request) const;
 
        template<typename DeleteEventTypeRequestT = Model::DeleteEventTypeRequest>
        Model::DeleteEventTypeOutcomeCallable DeleteEventTypeCallable(const DeleteEventTypeRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteEventType, request);
        }
 
        template<typename DeleteEventTypeRequestT = Model::DeleteEventTypeRequest>
        void DeleteEventTypeAsync(const DeleteEventTypeRequestT& request, const DeleteEventTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteEventType, request, handler, context);
        }
 
        virtual Model::DeleteEventsByEventTypeOutcome DeleteEventsByEventType(const Model::DeleteEventsByEventTypeRequest& request) const;
 
        template<typename DeleteEventsByEventTypeRequestT = Model::DeleteEventsByEventTypeRequest>
        Model::DeleteEventsByEventTypeOutcomeCallable DeleteEventsByEventTypeCallable(const DeleteEventsByEventTypeRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteEventsByEventType, request);
        }
 
        template<typename DeleteEventsByEventTypeRequestT = Model::DeleteEventsByEventTypeRequest>
        void DeleteEventsByEventTypeAsync(const DeleteEventsByEventTypeRequestT& request, const DeleteEventsByEventTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteEventsByEventType, request, handler, context);
        }
 
        virtual Model::DeleteExternalModelOutcome DeleteExternalModel(const Model::DeleteExternalModelRequest& request) const;
 
        template<typename DeleteExternalModelRequestT = Model::DeleteExternalModelRequest>
        Model::DeleteExternalModelOutcomeCallable DeleteExternalModelCallable(const DeleteExternalModelRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteExternalModel, request);
        }
 
        template<typename DeleteExternalModelRequestT = Model::DeleteExternalModelRequest>
        void DeleteExternalModelAsync(const DeleteExternalModelRequestT& request, const DeleteExternalModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteExternalModel, request, handler, context);
        }
 
        virtual Model::DeleteLabelOutcome DeleteLabel(const Model::DeleteLabelRequest& request) const;
 
        template<typename DeleteLabelRequestT = Model::DeleteLabelRequest>
        Model::DeleteLabelOutcomeCallable DeleteLabelCallable(const DeleteLabelRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteLabel, request);
        }
 
        template<typename DeleteLabelRequestT = Model::DeleteLabelRequest>
        void DeleteLabelAsync(const DeleteLabelRequestT& request, const DeleteLabelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteLabel, request, handler, context);
        }
 
        virtual Model::DeleteListOutcome DeleteList(const Model::DeleteListRequest& request) const;
 
        template<typename DeleteListRequestT = Model::DeleteListRequest>
        Model::DeleteListOutcomeCallable DeleteListCallable(const DeleteListRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteList, request);
        }
 
        template<typename DeleteListRequestT = Model::DeleteListRequest>
        void DeleteListAsync(const DeleteListRequestT& request, const DeleteListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteList, request, handler, context);
        }
 
        virtual Model::DeleteModelOutcome DeleteModel(const Model::DeleteModelRequest& request) const;
 
        template<typename DeleteModelRequestT = Model::DeleteModelRequest>
        Model::DeleteModelOutcomeCallable DeleteModelCallable(const DeleteModelRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteModel, request);
        }
 
        template<typename DeleteModelRequestT = Model::DeleteModelRequest>
        void DeleteModelAsync(const DeleteModelRequestT& request, const DeleteModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteModel, request, handler, context);
        }
 
        virtual Model::DeleteModelVersionOutcome DeleteModelVersion(const Model::DeleteModelVersionRequest& request) const;
 
        template<typename DeleteModelVersionRequestT = Model::DeleteModelVersionRequest>
        Model::DeleteModelVersionOutcomeCallable DeleteModelVersionCallable(const DeleteModelVersionRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteModelVersion, request);
        }
 
        template<typename DeleteModelVersionRequestT = Model::DeleteModelVersionRequest>
        void DeleteModelVersionAsync(const DeleteModelVersionRequestT& request, const DeleteModelVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteModelVersion, request, handler, context);
        }
 
        virtual Model::DeleteOutcomeOutcome DeleteOutcome(const Model::DeleteOutcomeRequest& request) const;
 
        template<typename DeleteOutcomeRequestT = Model::DeleteOutcomeRequest>
        Model::DeleteOutcomeOutcomeCallable DeleteOutcomeCallable(const DeleteOutcomeRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteOutcome, request);
        }
 
        template<typename DeleteOutcomeRequestT = Model::DeleteOutcomeRequest>
        void DeleteOutcomeAsync(const DeleteOutcomeRequestT& request, const DeleteOutcomeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteOutcome, request, handler, context);
        }
 
        virtual Model::DeleteRuleOutcome DeleteRule(const Model::DeleteRuleRequest& request) const;
 
        template<typename DeleteRuleRequestT = Model::DeleteRuleRequest>
        Model::DeleteRuleOutcomeCallable DeleteRuleCallable(const DeleteRuleRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteRule, request);
        }
 
        template<typename DeleteRuleRequestT = Model::DeleteRuleRequest>
        void DeleteRuleAsync(const DeleteRuleRequestT& request, const DeleteRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteRule, request, handler, context);
        }
 
        virtual Model::DeleteVariableOutcome DeleteVariable(const Model::DeleteVariableRequest& request) const;
 
        template<typename DeleteVariableRequestT = Model::DeleteVariableRequest>
        Model::DeleteVariableOutcomeCallable DeleteVariableCallable(const DeleteVariableRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DeleteVariable, request);
        }
 
        template<typename DeleteVariableRequestT = Model::DeleteVariableRequest>
        void DeleteVariableAsync(const DeleteVariableRequestT& request, const DeleteVariableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DeleteVariable, request, handler, context);
        }
 
        virtual Model::DescribeDetectorOutcome DescribeDetector(const Model::DescribeDetectorRequest& request) const;
 
        template<typename DescribeDetectorRequestT = Model::DescribeDetectorRequest>
        Model::DescribeDetectorOutcomeCallable DescribeDetectorCallable(const DescribeDetectorRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::DescribeDetector, request);
        }
 
        template<typename DescribeDetectorRequestT = Model::DescribeDetectorRequest>
        void DescribeDetectorAsync(const DescribeDetectorRequestT& request, const DescribeDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::DescribeDetector, request, handler, context);
        }
 
        virtual Model::DescribeModelVersionsOutcome DescribeModelVersions(const Model::DescribeModelVersionsRequest& request = {}) const;
 
        template<typename DescribeModelVersionsRequestT = Model::DescribeModelVersionsRequest>
        Model::DescribeModelVersionsOutcomeCallable DescribeModelVersionsCallable(const DescribeModelVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::DescribeModelVersions, request);
        }
 
        template<typename DescribeModelVersionsRequestT = Model::DescribeModelVersionsRequest>
        void DescribeModelVersionsAsync(const DescribeModelVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeModelVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::DescribeModelVersions, request, handler, context);
        }
 
        virtual Model::GetBatchImportJobsOutcome GetBatchImportJobs(const Model::GetBatchImportJobsRequest& request = {}) const;
 
        template<typename GetBatchImportJobsRequestT = Model::GetBatchImportJobsRequest>
        Model::GetBatchImportJobsOutcomeCallable GetBatchImportJobsCallable(const GetBatchImportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetBatchImportJobs, request);
        }
 
        template<typename GetBatchImportJobsRequestT = Model::GetBatchImportJobsRequest>
        void GetBatchImportJobsAsync(const GetBatchImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetBatchImportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetBatchImportJobs, request, handler, context);
        }
 
        virtual Model::GetBatchPredictionJobsOutcome GetBatchPredictionJobs(const Model::GetBatchPredictionJobsRequest& request = {}) const;
 
        template<typename GetBatchPredictionJobsRequestT = Model::GetBatchPredictionJobsRequest>
        Model::GetBatchPredictionJobsOutcomeCallable GetBatchPredictionJobsCallable(const GetBatchPredictionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetBatchPredictionJobs, request);
        }
 
        template<typename GetBatchPredictionJobsRequestT = Model::GetBatchPredictionJobsRequest>
        void GetBatchPredictionJobsAsync(const GetBatchPredictionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetBatchPredictionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetBatchPredictionJobs, request, handler, context);
        }
 
        virtual Model::GetDeleteEventsByEventTypeStatusOutcome GetDeleteEventsByEventTypeStatus(const Model::GetDeleteEventsByEventTypeStatusRequest& request) const;
 
        template<typename GetDeleteEventsByEventTypeStatusRequestT = Model::GetDeleteEventsByEventTypeStatusRequest>
        Model::GetDeleteEventsByEventTypeStatusOutcomeCallable GetDeleteEventsByEventTypeStatusCallable(const GetDeleteEventsByEventTypeStatusRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::GetDeleteEventsByEventTypeStatus, request);
        }
 
        template<typename GetDeleteEventsByEventTypeStatusRequestT = Model::GetDeleteEventsByEventTypeStatusRequest>
        void GetDeleteEventsByEventTypeStatusAsync(const GetDeleteEventsByEventTypeStatusRequestT& request, const GetDeleteEventsByEventTypeStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::GetDeleteEventsByEventTypeStatus, request, handler, context);
        }
 
        virtual Model::GetDetectorVersionOutcome GetDetectorVersion(const Model::GetDetectorVersionRequest& request) const;
 
        template<typename GetDetectorVersionRequestT = Model::GetDetectorVersionRequest>
        Model::GetDetectorVersionOutcomeCallable GetDetectorVersionCallable(const GetDetectorVersionRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::GetDetectorVersion, request);
        }
 
        template<typename GetDetectorVersionRequestT = Model::GetDetectorVersionRequest>
        void GetDetectorVersionAsync(const GetDetectorVersionRequestT& request, const GetDetectorVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::GetDetectorVersion, request, handler, context);
        }
 
        virtual Model::GetDetectorsOutcome GetDetectors(const Model::GetDetectorsRequest& request = {}) const;
 
        template<typename GetDetectorsRequestT = Model::GetDetectorsRequest>
        Model::GetDetectorsOutcomeCallable GetDetectorsCallable(const GetDetectorsRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetDetectors, request);
        }
 
        template<typename GetDetectorsRequestT = Model::GetDetectorsRequest>
        void GetDetectorsAsync(const GetDetectorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDetectorsRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetDetectors, request, handler, context);
        }
 
        virtual Model::GetEntityTypesOutcome GetEntityTypes(const Model::GetEntityTypesRequest& request = {}) const;
 
        template<typename GetEntityTypesRequestT = Model::GetEntityTypesRequest>
        Model::GetEntityTypesOutcomeCallable GetEntityTypesCallable(const GetEntityTypesRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetEntityTypes, request);
        }
 
        template<typename GetEntityTypesRequestT = Model::GetEntityTypesRequest>
        void GetEntityTypesAsync(const GetEntityTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetEntityTypesRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetEntityTypes, request, handler, context);
        }
 
        virtual Model::GetEventOutcome GetEvent(const Model::GetEventRequest& request) const;
 
        template<typename GetEventRequestT = Model::GetEventRequest>
        Model::GetEventOutcomeCallable GetEventCallable(const GetEventRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::GetEvent, request);
        }
 
        template<typename GetEventRequestT = Model::GetEventRequest>
        void GetEventAsync(const GetEventRequestT& request, const GetEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::GetEvent, request, handler, context);
        }
 
        virtual Model::GetEventPredictionOutcome GetEventPrediction(const Model::GetEventPredictionRequest& request) const;
 
        template<typename GetEventPredictionRequestT = Model::GetEventPredictionRequest>
        Model::GetEventPredictionOutcomeCallable GetEventPredictionCallable(const GetEventPredictionRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::GetEventPrediction, request);
        }
 
        template<typename GetEventPredictionRequestT = Model::GetEventPredictionRequest>
        void GetEventPredictionAsync(const GetEventPredictionRequestT& request, const GetEventPredictionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::GetEventPrediction, request, handler, context);
        }
 
        virtual Model::GetEventPredictionMetadataOutcome GetEventPredictionMetadata(const Model::GetEventPredictionMetadataRequest& request) const;
 
        template<typename GetEventPredictionMetadataRequestT = Model::GetEventPredictionMetadataRequest>
        Model::GetEventPredictionMetadataOutcomeCallable GetEventPredictionMetadataCallable(const GetEventPredictionMetadataRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::GetEventPredictionMetadata, request);
        }
 
        template<typename GetEventPredictionMetadataRequestT = Model::GetEventPredictionMetadataRequest>
        void GetEventPredictionMetadataAsync(const GetEventPredictionMetadataRequestT& request, const GetEventPredictionMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::GetEventPredictionMetadata, request, handler, context);
        }
 
        virtual Model::GetEventTypesOutcome GetEventTypes(const Model::GetEventTypesRequest& request = {}) const;
 
        template<typename GetEventTypesRequestT = Model::GetEventTypesRequest>
        Model::GetEventTypesOutcomeCallable GetEventTypesCallable(const GetEventTypesRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetEventTypes, request);
        }
 
        template<typename GetEventTypesRequestT = Model::GetEventTypesRequest>
        void GetEventTypesAsync(const GetEventTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetEventTypesRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetEventTypes, request, handler, context);
        }
 
        virtual Model::GetExternalModelsOutcome GetExternalModels(const Model::GetExternalModelsRequest& request = {}) const;
 
        template<typename GetExternalModelsRequestT = Model::GetExternalModelsRequest>
        Model::GetExternalModelsOutcomeCallable GetExternalModelsCallable(const GetExternalModelsRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetExternalModels, request);
        }
 
        template<typename GetExternalModelsRequestT = Model::GetExternalModelsRequest>
        void GetExternalModelsAsync(const GetExternalModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetExternalModelsRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetExternalModels, request, handler, context);
        }
 
        virtual Model::GetKMSEncryptionKeyOutcome GetKMSEncryptionKey(const Model::GetKMSEncryptionKeyRequest& request = {}) const;
 
        template<typename GetKMSEncryptionKeyRequestT = Model::GetKMSEncryptionKeyRequest>
        Model::GetKMSEncryptionKeyOutcomeCallable GetKMSEncryptionKeyCallable(const GetKMSEncryptionKeyRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetKMSEncryptionKey, request);
        }
 
        template<typename GetKMSEncryptionKeyRequestT = Model::GetKMSEncryptionKeyRequest>
        void GetKMSEncryptionKeyAsync(const GetKMSEncryptionKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetKMSEncryptionKeyRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetKMSEncryptionKey, request, handler, context);
        }
 
        virtual Model::GetLabelsOutcome GetLabels(const Model::GetLabelsRequest& request = {}) const;
 
        template<typename GetLabelsRequestT = Model::GetLabelsRequest>
        Model::GetLabelsOutcomeCallable GetLabelsCallable(const GetLabelsRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetLabels, request);
        }
 
        template<typename GetLabelsRequestT = Model::GetLabelsRequest>
        void GetLabelsAsync(const GetLabelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetLabelsRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetLabels, request, handler, context);
        }
 
        virtual Model::GetListElementsOutcome GetListElements(const Model::GetListElementsRequest& request) const;
 
        template<typename GetListElementsRequestT = Model::GetListElementsRequest>
        Model::GetListElementsOutcomeCallable GetListElementsCallable(const GetListElementsRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::GetListElements, request);
        }
 
        template<typename GetListElementsRequestT = Model::GetListElementsRequest>
        void GetListElementsAsync(const GetListElementsRequestT& request, const GetListElementsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::GetListElements, request, handler, context);
        }
 
        virtual Model::GetListsMetadataOutcome GetListsMetadata(const Model::GetListsMetadataRequest& request = {}) const;
 
        template<typename GetListsMetadataRequestT = Model::GetListsMetadataRequest>
        Model::GetListsMetadataOutcomeCallable GetListsMetadataCallable(const GetListsMetadataRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetListsMetadata, request);
        }
 
        template<typename GetListsMetadataRequestT = Model::GetListsMetadataRequest>
        void GetListsMetadataAsync(const GetListsMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetListsMetadataRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetListsMetadata, request, handler, context);
        }
 
        virtual Model::GetModelVersionOutcome GetModelVersion(const Model::GetModelVersionRequest& request) const;
 
        template<typename GetModelVersionRequestT = Model::GetModelVersionRequest>
        Model::GetModelVersionOutcomeCallable GetModelVersionCallable(const GetModelVersionRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::GetModelVersion, request);
        }
 
        template<typename GetModelVersionRequestT = Model::GetModelVersionRequest>
        void GetModelVersionAsync(const GetModelVersionRequestT& request, const GetModelVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::GetModelVersion, request, handler, context);
        }
 
        virtual Model::GetModelsOutcome GetModels(const Model::GetModelsRequest& request = {}) const;
 
        template<typename GetModelsRequestT = Model::GetModelsRequest>
        Model::GetModelsOutcomeCallable GetModelsCallable(const GetModelsRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetModels, request);
        }
 
        template<typename GetModelsRequestT = Model::GetModelsRequest>
        void GetModelsAsync(const GetModelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetModelsRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetModels, request, handler, context);
        }
 
        virtual Model::GetOutcomesOutcome GetOutcomes(const Model::GetOutcomesRequest& request = {}) const;
 
        template<typename GetOutcomesRequestT = Model::GetOutcomesRequest>
        Model::GetOutcomesOutcomeCallable GetOutcomesCallable(const GetOutcomesRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetOutcomes, request);
        }
 
        template<typename GetOutcomesRequestT = Model::GetOutcomesRequest>
        void GetOutcomesAsync(const GetOutcomesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetOutcomesRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetOutcomes, request, handler, context);
        }
 
        virtual Model::GetRulesOutcome GetRules(const Model::GetRulesRequest& request) const;
 
        template<typename GetRulesRequestT = Model::GetRulesRequest>
        Model::GetRulesOutcomeCallable GetRulesCallable(const GetRulesRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::GetRules, request);
        }
 
        template<typename GetRulesRequestT = Model::GetRulesRequest>
        void GetRulesAsync(const GetRulesRequestT& request, const GetRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::GetRules, request, handler, context);
        }
 
        virtual Model::GetVariablesOutcome GetVariables(const Model::GetVariablesRequest& request = {}) const;
 
        template<typename GetVariablesRequestT = Model::GetVariablesRequest>
        Model::GetVariablesOutcomeCallable GetVariablesCallable(const GetVariablesRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::GetVariables, request);
        }
 
        template<typename GetVariablesRequestT = Model::GetVariablesRequest>
        void GetVariablesAsync(const GetVariablesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetVariablesRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::GetVariables, request, handler, context);
        }
 
        virtual Model::ListEventPredictionsOutcome ListEventPredictions(const Model::ListEventPredictionsRequest& request = {}) const;
 
        template<typename ListEventPredictionsRequestT = Model::ListEventPredictionsRequest>
        Model::ListEventPredictionsOutcomeCallable ListEventPredictionsCallable(const ListEventPredictionsRequestT& request = {}) const
        {
            return SubmitCallable(&FraudDetectorClient::ListEventPredictions, request);
        }
 
        template<typename ListEventPredictionsRequestT = Model::ListEventPredictionsRequest>
        void ListEventPredictionsAsync(const ListEventPredictionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEventPredictionsRequestT& request = {}) const
        {
            return SubmitAsync(&FraudDetectorClient::ListEventPredictions, request, handler, context);
        }
 
        virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::ListTagsForResource, request);
        }
 
        template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
        void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutDetectorOutcome PutDetector(const Model::PutDetectorRequest& request) const;
 
        template<typename PutDetectorRequestT = Model::PutDetectorRequest>
        Model::PutDetectorOutcomeCallable PutDetectorCallable(const PutDetectorRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::PutDetector, request);
        }
 
        template<typename PutDetectorRequestT = Model::PutDetectorRequest>
        void PutDetectorAsync(const PutDetectorRequestT& request, const PutDetectorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::PutDetector, request, handler, context);
        }
 
        virtual Model::PutEntityTypeOutcome PutEntityType(const Model::PutEntityTypeRequest& request) const;
 
        template<typename PutEntityTypeRequestT = Model::PutEntityTypeRequest>
        Model::PutEntityTypeOutcomeCallable PutEntityTypeCallable(const PutEntityTypeRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::PutEntityType, request);
        }
 
        template<typename PutEntityTypeRequestT = Model::PutEntityTypeRequest>
        void PutEntityTypeAsync(const PutEntityTypeRequestT& request, const PutEntityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::PutEntityType, request, handler, context);
        }
 
        virtual Model::PutEventTypeOutcome PutEventType(const Model::PutEventTypeRequest& request) const;
 
        template<typename PutEventTypeRequestT = Model::PutEventTypeRequest>
        Model::PutEventTypeOutcomeCallable PutEventTypeCallable(const PutEventTypeRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::PutEventType, request);
        }
 
        template<typename PutEventTypeRequestT = Model::PutEventTypeRequest>
        void PutEventTypeAsync(const PutEventTypeRequestT& request, const PutEventTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::PutEventType, request, handler, context);
        }
 
        virtual Model::PutExternalModelOutcome PutExternalModel(const Model::PutExternalModelRequest& request) const;
 
        template<typename PutExternalModelRequestT = Model::PutExternalModelRequest>
        Model::PutExternalModelOutcomeCallable PutExternalModelCallable(const PutExternalModelRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::PutExternalModel, request);
        }
 
        template<typename PutExternalModelRequestT = Model::PutExternalModelRequest>
        void PutExternalModelAsync(const PutExternalModelRequestT& request, const PutExternalModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::PutExternalModel, request, handler, context);
        }
 
        virtual Model::PutKMSEncryptionKeyOutcome PutKMSEncryptionKey(const Model::PutKMSEncryptionKeyRequest& request) const;
 
        template<typename PutKMSEncryptionKeyRequestT = Model::PutKMSEncryptionKeyRequest>
        Model::PutKMSEncryptionKeyOutcomeCallable PutKMSEncryptionKeyCallable(const PutKMSEncryptionKeyRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::PutKMSEncryptionKey, request);
        }
 
        template<typename PutKMSEncryptionKeyRequestT = Model::PutKMSEncryptionKeyRequest>
        void PutKMSEncryptionKeyAsync(const PutKMSEncryptionKeyRequestT& request, const PutKMSEncryptionKeyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::PutKMSEncryptionKey, request, handler, context);
        }
 
        virtual Model::PutLabelOutcome PutLabel(const Model::PutLabelRequest& request) const;
 
        template<typename PutLabelRequestT = Model::PutLabelRequest>
        Model::PutLabelOutcomeCallable PutLabelCallable(const PutLabelRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::PutLabel, request);
        }
 
        template<typename PutLabelRequestT = Model::PutLabelRequest>
        void PutLabelAsync(const PutLabelRequestT& request, const PutLabelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::PutLabel, request, handler, context);
        }
 
        virtual Model::PutOutcomeOutcome PutOutcome(const Model::PutOutcomeRequest& request) const;
 
        template<typename PutOutcomeRequestT = Model::PutOutcomeRequest>
        Model::PutOutcomeOutcomeCallable PutOutcomeCallable(const PutOutcomeRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::PutOutcome, request);
        }
 
        template<typename PutOutcomeRequestT = Model::PutOutcomeRequest>
        void PutOutcomeAsync(const PutOutcomeRequestT& request, const PutOutcomeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::PutOutcome, request, handler, context);
        }
 
        virtual Model::SendEventOutcome SendEvent(const Model::SendEventRequest& request) const;
 
        template<typename SendEventRequestT = Model::SendEventRequest>
        Model::SendEventOutcomeCallable SendEventCallable(const SendEventRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::SendEvent, request);
        }
 
        template<typename SendEventRequestT = Model::SendEventRequest>
        void SendEventAsync(const SendEventRequestT& request, const SendEventResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::SendEvent, request, handler, context);
        }
 
        virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::TagResource, request);
        }
 
        template<typename TagResourceRequestT = Model::TagResourceRequest>
        void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::TagResource, request, handler, context);
        }
 
        virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UntagResource, request);
        }
 
        template<typename UntagResourceRequestT = Model::UntagResourceRequest>
        void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateDetectorVersionOutcome UpdateDetectorVersion(const Model::UpdateDetectorVersionRequest& request) const;
 
        template<typename UpdateDetectorVersionRequestT = Model::UpdateDetectorVersionRequest>
        Model::UpdateDetectorVersionOutcomeCallable UpdateDetectorVersionCallable(const UpdateDetectorVersionRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateDetectorVersion, request);
        }
 
        template<typename UpdateDetectorVersionRequestT = Model::UpdateDetectorVersionRequest>
        void UpdateDetectorVersionAsync(const UpdateDetectorVersionRequestT& request, const UpdateDetectorVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateDetectorVersion, request, handler, context);
        }
 
        virtual Model::UpdateDetectorVersionMetadataOutcome UpdateDetectorVersionMetadata(const Model::UpdateDetectorVersionMetadataRequest& request) const;
 
        template<typename UpdateDetectorVersionMetadataRequestT = Model::UpdateDetectorVersionMetadataRequest>
        Model::UpdateDetectorVersionMetadataOutcomeCallable UpdateDetectorVersionMetadataCallable(const UpdateDetectorVersionMetadataRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateDetectorVersionMetadata, request);
        }
 
        template<typename UpdateDetectorVersionMetadataRequestT = Model::UpdateDetectorVersionMetadataRequest>
        void UpdateDetectorVersionMetadataAsync(const UpdateDetectorVersionMetadataRequestT& request, const UpdateDetectorVersionMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateDetectorVersionMetadata, request, handler, context);
        }
 
        virtual Model::UpdateDetectorVersionStatusOutcome UpdateDetectorVersionStatus(const Model::UpdateDetectorVersionStatusRequest& request) const;
 
        template<typename UpdateDetectorVersionStatusRequestT = Model::UpdateDetectorVersionStatusRequest>
        Model::UpdateDetectorVersionStatusOutcomeCallable UpdateDetectorVersionStatusCallable(const UpdateDetectorVersionStatusRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateDetectorVersionStatus, request);
        }
 
        template<typename UpdateDetectorVersionStatusRequestT = Model::UpdateDetectorVersionStatusRequest>
        void UpdateDetectorVersionStatusAsync(const UpdateDetectorVersionStatusRequestT& request, const UpdateDetectorVersionStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateDetectorVersionStatus, request, handler, context);
        }
 
        virtual Model::UpdateEventLabelOutcome UpdateEventLabel(const Model::UpdateEventLabelRequest& request) const;
 
        template<typename UpdateEventLabelRequestT = Model::UpdateEventLabelRequest>
        Model::UpdateEventLabelOutcomeCallable UpdateEventLabelCallable(const UpdateEventLabelRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateEventLabel, request);
        }
 
        template<typename UpdateEventLabelRequestT = Model::UpdateEventLabelRequest>
        void UpdateEventLabelAsync(const UpdateEventLabelRequestT& request, const UpdateEventLabelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateEventLabel, request, handler, context);
        }
 
        virtual Model::UpdateListOutcome UpdateList(const Model::UpdateListRequest& request) const;
 
        template<typename UpdateListRequestT = Model::UpdateListRequest>
        Model::UpdateListOutcomeCallable UpdateListCallable(const UpdateListRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateList, request);
        }
 
        template<typename UpdateListRequestT = Model::UpdateListRequest>
        void UpdateListAsync(const UpdateListRequestT& request, const UpdateListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateList, request, handler, context);
        }
 
        virtual Model::UpdateModelOutcome UpdateModel(const Model::UpdateModelRequest& request) const;
 
        template<typename UpdateModelRequestT = Model::UpdateModelRequest>
        Model::UpdateModelOutcomeCallable UpdateModelCallable(const UpdateModelRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateModel, request);
        }
 
        template<typename UpdateModelRequestT = Model::UpdateModelRequest>
        void UpdateModelAsync(const UpdateModelRequestT& request, const UpdateModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateModel, request, handler, context);
        }
 
        virtual Model::UpdateModelVersionOutcome UpdateModelVersion(const Model::UpdateModelVersionRequest& request) const;
 
        template<typename UpdateModelVersionRequestT = Model::UpdateModelVersionRequest>
        Model::UpdateModelVersionOutcomeCallable UpdateModelVersionCallable(const UpdateModelVersionRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateModelVersion, request);
        }
 
        template<typename UpdateModelVersionRequestT = Model::UpdateModelVersionRequest>
        void UpdateModelVersionAsync(const UpdateModelVersionRequestT& request, const UpdateModelVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateModelVersion, request, handler, context);
        }
 
        virtual Model::UpdateModelVersionStatusOutcome UpdateModelVersionStatus(const Model::UpdateModelVersionStatusRequest& request) const;
 
        template<typename UpdateModelVersionStatusRequestT = Model::UpdateModelVersionStatusRequest>
        Model::UpdateModelVersionStatusOutcomeCallable UpdateModelVersionStatusCallable(const UpdateModelVersionStatusRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateModelVersionStatus, request);
        }
 
        template<typename UpdateModelVersionStatusRequestT = Model::UpdateModelVersionStatusRequest>
        void UpdateModelVersionStatusAsync(const UpdateModelVersionStatusRequestT& request, const UpdateModelVersionStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateModelVersionStatus, request, handler, context);
        }
 
        virtual Model::UpdateRuleMetadataOutcome UpdateRuleMetadata(const Model::UpdateRuleMetadataRequest& request) const;
 
        template<typename UpdateRuleMetadataRequestT = Model::UpdateRuleMetadataRequest>
        Model::UpdateRuleMetadataOutcomeCallable UpdateRuleMetadataCallable(const UpdateRuleMetadataRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateRuleMetadata, request);
        }
 
        template<typename UpdateRuleMetadataRequestT = Model::UpdateRuleMetadataRequest>
        void UpdateRuleMetadataAsync(const UpdateRuleMetadataRequestT& request, const UpdateRuleMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateRuleMetadata, request, handler, context);
        }
 
        virtual Model::UpdateRuleVersionOutcome UpdateRuleVersion(const Model::UpdateRuleVersionRequest& request) const;
 
        template<typename UpdateRuleVersionRequestT = Model::UpdateRuleVersionRequest>
        Model::UpdateRuleVersionOutcomeCallable UpdateRuleVersionCallable(const UpdateRuleVersionRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateRuleVersion, request);
        }
 
        template<typename UpdateRuleVersionRequestT = Model::UpdateRuleVersionRequest>
        void UpdateRuleVersionAsync(const UpdateRuleVersionRequestT& request, const UpdateRuleVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateRuleVersion, request, handler, context);
        }
 
        virtual Model::UpdateVariableOutcome UpdateVariable(const Model::UpdateVariableRequest& request) const;
 
        template<typename UpdateVariableRequestT = Model::UpdateVariableRequest>
        Model::UpdateVariableOutcomeCallable UpdateVariableCallable(const UpdateVariableRequestT& request) const
        {
            return SubmitCallable(&FraudDetectorClient::UpdateVariable, request);
        }
 
        template<typename UpdateVariableRequestT = Model::UpdateVariableRequest>
        void UpdateVariableAsync(const UpdateVariableRequestT& request, const UpdateVariableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FraudDetectorClient::UpdateVariable, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<FraudDetectorEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<FraudDetectorClient>;
      void init(const FraudDetectorClientConfiguration& clientConfiguration);
 
      FraudDetectorClientConfiguration m_clientConfiguration;
      std::shared_ptr<FraudDetectorEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace FraudDetector
} // namespace Aws