PersonalizeClient.h

 
#pragma once
#include <aws/personalize/Personalize_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/personalize/PersonalizeServiceClientModel.h>
 
namespace Aws
{
namespace Personalize
{
  class AWS_PERSONALIZE_API PersonalizeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<PersonalizeClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef PersonalizeClientConfiguration ClientConfigurationType;
      typedef PersonalizeEndpointProvider EndpointProviderType;
 
        PersonalizeClient(const Aws::Personalize::PersonalizeClientConfiguration& clientConfiguration = Aws::Personalize::PersonalizeClientConfiguration(),
                          std::shared_ptr<PersonalizeEndpointProviderBase> endpointProvider = nullptr);
 
        PersonalizeClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<PersonalizeEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::Personalize::PersonalizeClientConfiguration& clientConfiguration = Aws::Personalize::PersonalizeClientConfiguration());
 
        PersonalizeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<PersonalizeEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::Personalize::PersonalizeClientConfiguration& clientConfiguration = Aws::Personalize::PersonalizeClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        PersonalizeClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        PersonalizeClient(const Aws::Auth::AWSCredentials& credentials,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        PersonalizeClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~PersonalizeClient();
 
        virtual Model::CreateBatchInferenceJobOutcome CreateBatchInferenceJob(const Model::CreateBatchInferenceJobRequest& request) const;
 
        template<typename CreateBatchInferenceJobRequestT = Model::CreateBatchInferenceJobRequest>
        Model::CreateBatchInferenceJobOutcomeCallable CreateBatchInferenceJobCallable(const CreateBatchInferenceJobRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateBatchInferenceJob, request);
        }
 
        template<typename CreateBatchInferenceJobRequestT = Model::CreateBatchInferenceJobRequest>
        void CreateBatchInferenceJobAsync(const CreateBatchInferenceJobRequestT& request, const CreateBatchInferenceJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateBatchInferenceJob, request, handler, context);
        }
 
        virtual Model::CreateBatchSegmentJobOutcome CreateBatchSegmentJob(const Model::CreateBatchSegmentJobRequest& request) const;
 
        template<typename CreateBatchSegmentJobRequestT = Model::CreateBatchSegmentJobRequest>
        Model::CreateBatchSegmentJobOutcomeCallable CreateBatchSegmentJobCallable(const CreateBatchSegmentJobRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateBatchSegmentJob, request);
        }
 
        template<typename CreateBatchSegmentJobRequestT = Model::CreateBatchSegmentJobRequest>
        void CreateBatchSegmentJobAsync(const CreateBatchSegmentJobRequestT& request, const CreateBatchSegmentJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateBatchSegmentJob, request, handler, context);
        }
 
        virtual Model::CreateCampaignOutcome CreateCampaign(const Model::CreateCampaignRequest& request) const;
 
        template<typename CreateCampaignRequestT = Model::CreateCampaignRequest>
        Model::CreateCampaignOutcomeCallable CreateCampaignCallable(const CreateCampaignRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateCampaign, request);
        }
 
        template<typename CreateCampaignRequestT = Model::CreateCampaignRequest>
        void CreateCampaignAsync(const CreateCampaignRequestT& request, const CreateCampaignResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateCampaign, request, handler, context);
        }
 
        virtual Model::CreateDataDeletionJobOutcome CreateDataDeletionJob(const Model::CreateDataDeletionJobRequest& request) const;
 
        template<typename CreateDataDeletionJobRequestT = Model::CreateDataDeletionJobRequest>
        Model::CreateDataDeletionJobOutcomeCallable CreateDataDeletionJobCallable(const CreateDataDeletionJobRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateDataDeletionJob, request);
        }
 
        template<typename CreateDataDeletionJobRequestT = Model::CreateDataDeletionJobRequest>
        void CreateDataDeletionJobAsync(const CreateDataDeletionJobRequestT& request, const CreateDataDeletionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateDataDeletionJob, request, handler, context);
        }
 
        virtual Model::CreateDatasetOutcome CreateDataset(const Model::CreateDatasetRequest& request) const;
 
        template<typename CreateDatasetRequestT = Model::CreateDatasetRequest>
        Model::CreateDatasetOutcomeCallable CreateDatasetCallable(const CreateDatasetRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateDataset, request);
        }
 
        template<typename CreateDatasetRequestT = Model::CreateDatasetRequest>
        void CreateDatasetAsync(const CreateDatasetRequestT& request, const CreateDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateDataset, request, handler, context);
        }
 
        virtual Model::CreateDatasetExportJobOutcome CreateDatasetExportJob(const Model::CreateDatasetExportJobRequest& request) const;
 
        template<typename CreateDatasetExportJobRequestT = Model::CreateDatasetExportJobRequest>
        Model::CreateDatasetExportJobOutcomeCallable CreateDatasetExportJobCallable(const CreateDatasetExportJobRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateDatasetExportJob, request);
        }
 
        template<typename CreateDatasetExportJobRequestT = Model::CreateDatasetExportJobRequest>
        void CreateDatasetExportJobAsync(const CreateDatasetExportJobRequestT& request, const CreateDatasetExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateDatasetExportJob, request, handler, context);
        }
 
        virtual Model::CreateDatasetGroupOutcome CreateDatasetGroup(const Model::CreateDatasetGroupRequest& request) const;
 
        template<typename CreateDatasetGroupRequestT = Model::CreateDatasetGroupRequest>
        Model::CreateDatasetGroupOutcomeCallable CreateDatasetGroupCallable(const CreateDatasetGroupRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateDatasetGroup, request);
        }
 
        template<typename CreateDatasetGroupRequestT = Model::CreateDatasetGroupRequest>
        void CreateDatasetGroupAsync(const CreateDatasetGroupRequestT& request, const CreateDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateDatasetGroup, request, handler, context);
        }
 
        virtual Model::CreateDatasetImportJobOutcome CreateDatasetImportJob(const Model::CreateDatasetImportJobRequest& request) const;
 
        template<typename CreateDatasetImportJobRequestT = Model::CreateDatasetImportJobRequest>
        Model::CreateDatasetImportJobOutcomeCallable CreateDatasetImportJobCallable(const CreateDatasetImportJobRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateDatasetImportJob, request);
        }
 
        template<typename CreateDatasetImportJobRequestT = Model::CreateDatasetImportJobRequest>
        void CreateDatasetImportJobAsync(const CreateDatasetImportJobRequestT& request, const CreateDatasetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateDatasetImportJob, request, handler, context);
        }
 
        virtual Model::CreateEventTrackerOutcome CreateEventTracker(const Model::CreateEventTrackerRequest& request) const;
 
        template<typename CreateEventTrackerRequestT = Model::CreateEventTrackerRequest>
        Model::CreateEventTrackerOutcomeCallable CreateEventTrackerCallable(const CreateEventTrackerRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateEventTracker, request);
        }
 
        template<typename CreateEventTrackerRequestT = Model::CreateEventTrackerRequest>
        void CreateEventTrackerAsync(const CreateEventTrackerRequestT& request, const CreateEventTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateEventTracker, request, handler, context);
        }
 
        virtual Model::CreateFilterOutcome CreateFilter(const Model::CreateFilterRequest& request) const;
 
        template<typename CreateFilterRequestT = Model::CreateFilterRequest>
        Model::CreateFilterOutcomeCallable CreateFilterCallable(const CreateFilterRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateFilter, request);
        }
 
        template<typename CreateFilterRequestT = Model::CreateFilterRequest>
        void CreateFilterAsync(const CreateFilterRequestT& request, const CreateFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateFilter, request, handler, context);
        }
 
        virtual Model::CreateMetricAttributionOutcome CreateMetricAttribution(const Model::CreateMetricAttributionRequest& request) const;
 
        template<typename CreateMetricAttributionRequestT = Model::CreateMetricAttributionRequest>
        Model::CreateMetricAttributionOutcomeCallable CreateMetricAttributionCallable(const CreateMetricAttributionRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateMetricAttribution, request);
        }
 
        template<typename CreateMetricAttributionRequestT = Model::CreateMetricAttributionRequest>
        void CreateMetricAttributionAsync(const CreateMetricAttributionRequestT& request, const CreateMetricAttributionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateMetricAttribution, request, handler, context);
        }
 
        virtual Model::CreateRecommenderOutcome CreateRecommender(const Model::CreateRecommenderRequest& request) const;
 
        template<typename CreateRecommenderRequestT = Model::CreateRecommenderRequest>
        Model::CreateRecommenderOutcomeCallable CreateRecommenderCallable(const CreateRecommenderRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateRecommender, request);
        }
 
        template<typename CreateRecommenderRequestT = Model::CreateRecommenderRequest>
        void CreateRecommenderAsync(const CreateRecommenderRequestT& request, const CreateRecommenderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateRecommender, request, handler, context);
        }
 
        virtual Model::CreateSchemaOutcome CreateSchema(const Model::CreateSchemaRequest& request) const;
 
        template<typename CreateSchemaRequestT = Model::CreateSchemaRequest>
        Model::CreateSchemaOutcomeCallable CreateSchemaCallable(const CreateSchemaRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateSchema, request);
        }
 
        template<typename CreateSchemaRequestT = Model::CreateSchemaRequest>
        void CreateSchemaAsync(const CreateSchemaRequestT& request, const CreateSchemaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateSchema, request, handler, context);
        }
 
        virtual Model::CreateSolutionOutcome CreateSolution(const Model::CreateSolutionRequest& request) const;
 
        template<typename CreateSolutionRequestT = Model::CreateSolutionRequest>
        Model::CreateSolutionOutcomeCallable CreateSolutionCallable(const CreateSolutionRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateSolution, request);
        }
 
        template<typename CreateSolutionRequestT = Model::CreateSolutionRequest>
        void CreateSolutionAsync(const CreateSolutionRequestT& request, const CreateSolutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateSolution, request, handler, context);
        }
 
        virtual Model::CreateSolutionVersionOutcome CreateSolutionVersion(const Model::CreateSolutionVersionRequest& request) const;
 
        template<typename CreateSolutionVersionRequestT = Model::CreateSolutionVersionRequest>
        Model::CreateSolutionVersionOutcomeCallable CreateSolutionVersionCallable(const CreateSolutionVersionRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::CreateSolutionVersion, request);
        }
 
        template<typename CreateSolutionVersionRequestT = Model::CreateSolutionVersionRequest>
        void CreateSolutionVersionAsync(const CreateSolutionVersionRequestT& request, const CreateSolutionVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::CreateSolutionVersion, request, handler, context);
        }
 
        virtual Model::DeleteCampaignOutcome DeleteCampaign(const Model::DeleteCampaignRequest& request) const;
 
        template<typename DeleteCampaignRequestT = Model::DeleteCampaignRequest>
        Model::DeleteCampaignOutcomeCallable DeleteCampaignCallable(const DeleteCampaignRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DeleteCampaign, request);
        }
 
        template<typename DeleteCampaignRequestT = Model::DeleteCampaignRequest>
        void DeleteCampaignAsync(const DeleteCampaignRequestT& request, const DeleteCampaignResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DeleteCampaign, request, handler, context);
        }
 
        virtual Model::DeleteDatasetOutcome DeleteDataset(const Model::DeleteDatasetRequest& request) const;
 
        template<typename DeleteDatasetRequestT = Model::DeleteDatasetRequest>
        Model::DeleteDatasetOutcomeCallable DeleteDatasetCallable(const DeleteDatasetRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DeleteDataset, request);
        }
 
        template<typename DeleteDatasetRequestT = Model::DeleteDatasetRequest>
        void DeleteDatasetAsync(const DeleteDatasetRequestT& request, const DeleteDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DeleteDataset, request, handler, context);
        }
 
        virtual Model::DeleteDatasetGroupOutcome DeleteDatasetGroup(const Model::DeleteDatasetGroupRequest& request) const;
 
        template<typename DeleteDatasetGroupRequestT = Model::DeleteDatasetGroupRequest>
        Model::DeleteDatasetGroupOutcomeCallable DeleteDatasetGroupCallable(const DeleteDatasetGroupRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DeleteDatasetGroup, request);
        }
 
        template<typename DeleteDatasetGroupRequestT = Model::DeleteDatasetGroupRequest>
        void DeleteDatasetGroupAsync(const DeleteDatasetGroupRequestT& request, const DeleteDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DeleteDatasetGroup, request, handler, context);
        }
 
        virtual Model::DeleteEventTrackerOutcome DeleteEventTracker(const Model::DeleteEventTrackerRequest& request) const;
 
        template<typename DeleteEventTrackerRequestT = Model::DeleteEventTrackerRequest>
        Model::DeleteEventTrackerOutcomeCallable DeleteEventTrackerCallable(const DeleteEventTrackerRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DeleteEventTracker, request);
        }
 
        template<typename DeleteEventTrackerRequestT = Model::DeleteEventTrackerRequest>
        void DeleteEventTrackerAsync(const DeleteEventTrackerRequestT& request, const DeleteEventTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DeleteEventTracker, request, handler, context);
        }
 
        virtual Model::DeleteFilterOutcome DeleteFilter(const Model::DeleteFilterRequest& request) const;
 
        template<typename DeleteFilterRequestT = Model::DeleteFilterRequest>
        Model::DeleteFilterOutcomeCallable DeleteFilterCallable(const DeleteFilterRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DeleteFilter, request);
        }
 
        template<typename DeleteFilterRequestT = Model::DeleteFilterRequest>
        void DeleteFilterAsync(const DeleteFilterRequestT& request, const DeleteFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DeleteFilter, request, handler, context);
        }
 
        virtual Model::DeleteMetricAttributionOutcome DeleteMetricAttribution(const Model::DeleteMetricAttributionRequest& request) const;
 
        template<typename DeleteMetricAttributionRequestT = Model::DeleteMetricAttributionRequest>
        Model::DeleteMetricAttributionOutcomeCallable DeleteMetricAttributionCallable(const DeleteMetricAttributionRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DeleteMetricAttribution, request);
        }
 
        template<typename DeleteMetricAttributionRequestT = Model::DeleteMetricAttributionRequest>
        void DeleteMetricAttributionAsync(const DeleteMetricAttributionRequestT& request, const DeleteMetricAttributionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DeleteMetricAttribution, request, handler, context);
        }
 
        virtual Model::DeleteRecommenderOutcome DeleteRecommender(const Model::DeleteRecommenderRequest& request) const;
 
        template<typename DeleteRecommenderRequestT = Model::DeleteRecommenderRequest>
        Model::DeleteRecommenderOutcomeCallable DeleteRecommenderCallable(const DeleteRecommenderRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DeleteRecommender, request);
        }
 
        template<typename DeleteRecommenderRequestT = Model::DeleteRecommenderRequest>
        void DeleteRecommenderAsync(const DeleteRecommenderRequestT& request, const DeleteRecommenderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DeleteRecommender, request, handler, context);
        }
 
        virtual Model::DeleteSchemaOutcome DeleteSchema(const Model::DeleteSchemaRequest& request) const;
 
        template<typename DeleteSchemaRequestT = Model::DeleteSchemaRequest>
        Model::DeleteSchemaOutcomeCallable DeleteSchemaCallable(const DeleteSchemaRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DeleteSchema, request);
        }
 
        template<typename DeleteSchemaRequestT = Model::DeleteSchemaRequest>
        void DeleteSchemaAsync(const DeleteSchemaRequestT& request, const DeleteSchemaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DeleteSchema, request, handler, context);
        }
 
        virtual Model::DeleteSolutionOutcome DeleteSolution(const Model::DeleteSolutionRequest& request) const;
 
        template<typename DeleteSolutionRequestT = Model::DeleteSolutionRequest>
        Model::DeleteSolutionOutcomeCallable DeleteSolutionCallable(const DeleteSolutionRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DeleteSolution, request);
        }
 
        template<typename DeleteSolutionRequestT = Model::DeleteSolutionRequest>
        void DeleteSolutionAsync(const DeleteSolutionRequestT& request, const DeleteSolutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DeleteSolution, request, handler, context);
        }
 
        virtual Model::DescribeAlgorithmOutcome DescribeAlgorithm(const Model::DescribeAlgorithmRequest& request) const;
 
        template<typename DescribeAlgorithmRequestT = Model::DescribeAlgorithmRequest>
        Model::DescribeAlgorithmOutcomeCallable DescribeAlgorithmCallable(const DescribeAlgorithmRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeAlgorithm, request);
        }
 
        template<typename DescribeAlgorithmRequestT = Model::DescribeAlgorithmRequest>
        void DescribeAlgorithmAsync(const DescribeAlgorithmRequestT& request, const DescribeAlgorithmResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeAlgorithm, request, handler, context);
        }
 
        virtual Model::DescribeBatchInferenceJobOutcome DescribeBatchInferenceJob(const Model::DescribeBatchInferenceJobRequest& request) const;
 
        template<typename DescribeBatchInferenceJobRequestT = Model::DescribeBatchInferenceJobRequest>
        Model::DescribeBatchInferenceJobOutcomeCallable DescribeBatchInferenceJobCallable(const DescribeBatchInferenceJobRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeBatchInferenceJob, request);
        }
 
        template<typename DescribeBatchInferenceJobRequestT = Model::DescribeBatchInferenceJobRequest>
        void DescribeBatchInferenceJobAsync(const DescribeBatchInferenceJobRequestT& request, const DescribeBatchInferenceJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeBatchInferenceJob, request, handler, context);
        }
 
        virtual Model::DescribeBatchSegmentJobOutcome DescribeBatchSegmentJob(const Model::DescribeBatchSegmentJobRequest& request) const;
 
        template<typename DescribeBatchSegmentJobRequestT = Model::DescribeBatchSegmentJobRequest>
        Model::DescribeBatchSegmentJobOutcomeCallable DescribeBatchSegmentJobCallable(const DescribeBatchSegmentJobRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeBatchSegmentJob, request);
        }
 
        template<typename DescribeBatchSegmentJobRequestT = Model::DescribeBatchSegmentJobRequest>
        void DescribeBatchSegmentJobAsync(const DescribeBatchSegmentJobRequestT& request, const DescribeBatchSegmentJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeBatchSegmentJob, request, handler, context);
        }
 
        virtual Model::DescribeCampaignOutcome DescribeCampaign(const Model::DescribeCampaignRequest& request) const;
 
        template<typename DescribeCampaignRequestT = Model::DescribeCampaignRequest>
        Model::DescribeCampaignOutcomeCallable DescribeCampaignCallable(const DescribeCampaignRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeCampaign, request);
        }
 
        template<typename DescribeCampaignRequestT = Model::DescribeCampaignRequest>
        void DescribeCampaignAsync(const DescribeCampaignRequestT& request, const DescribeCampaignResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeCampaign, request, handler, context);
        }
 
        virtual Model::DescribeDataDeletionJobOutcome DescribeDataDeletionJob(const Model::DescribeDataDeletionJobRequest& request) const;
 
        template<typename DescribeDataDeletionJobRequestT = Model::DescribeDataDeletionJobRequest>
        Model::DescribeDataDeletionJobOutcomeCallable DescribeDataDeletionJobCallable(const DescribeDataDeletionJobRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeDataDeletionJob, request);
        }
 
        template<typename DescribeDataDeletionJobRequestT = Model::DescribeDataDeletionJobRequest>
        void DescribeDataDeletionJobAsync(const DescribeDataDeletionJobRequestT& request, const DescribeDataDeletionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeDataDeletionJob, request, handler, context);
        }
 
        virtual Model::DescribeDatasetOutcome DescribeDataset(const Model::DescribeDatasetRequest& request) const;
 
        template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
        Model::DescribeDatasetOutcomeCallable DescribeDatasetCallable(const DescribeDatasetRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeDataset, request);
        }
 
        template<typename DescribeDatasetRequestT = Model::DescribeDatasetRequest>
        void DescribeDatasetAsync(const DescribeDatasetRequestT& request, const DescribeDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeDataset, request, handler, context);
        }
 
        virtual Model::DescribeDatasetExportJobOutcome DescribeDatasetExportJob(const Model::DescribeDatasetExportJobRequest& request) const;
 
        template<typename DescribeDatasetExportJobRequestT = Model::DescribeDatasetExportJobRequest>
        Model::DescribeDatasetExportJobOutcomeCallable DescribeDatasetExportJobCallable(const DescribeDatasetExportJobRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeDatasetExportJob, request);
        }
 
        template<typename DescribeDatasetExportJobRequestT = Model::DescribeDatasetExportJobRequest>
        void DescribeDatasetExportJobAsync(const DescribeDatasetExportJobRequestT& request, const DescribeDatasetExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeDatasetExportJob, request, handler, context);
        }
 
        virtual Model::DescribeDatasetGroupOutcome DescribeDatasetGroup(const Model::DescribeDatasetGroupRequest& request) const;
 
        template<typename DescribeDatasetGroupRequestT = Model::DescribeDatasetGroupRequest>
        Model::DescribeDatasetGroupOutcomeCallable DescribeDatasetGroupCallable(const DescribeDatasetGroupRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeDatasetGroup, request);
        }
 
        template<typename DescribeDatasetGroupRequestT = Model::DescribeDatasetGroupRequest>
        void DescribeDatasetGroupAsync(const DescribeDatasetGroupRequestT& request, const DescribeDatasetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeDatasetGroup, request, handler, context);
        }
 
        virtual Model::DescribeDatasetImportJobOutcome DescribeDatasetImportJob(const Model::DescribeDatasetImportJobRequest& request) const;
 
        template<typename DescribeDatasetImportJobRequestT = Model::DescribeDatasetImportJobRequest>
        Model::DescribeDatasetImportJobOutcomeCallable DescribeDatasetImportJobCallable(const DescribeDatasetImportJobRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeDatasetImportJob, request);
        }
 
        template<typename DescribeDatasetImportJobRequestT = Model::DescribeDatasetImportJobRequest>
        void DescribeDatasetImportJobAsync(const DescribeDatasetImportJobRequestT& request, const DescribeDatasetImportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeDatasetImportJob, request, handler, context);
        }
 
        virtual Model::DescribeEventTrackerOutcome DescribeEventTracker(const Model::DescribeEventTrackerRequest& request) const;
 
        template<typename DescribeEventTrackerRequestT = Model::DescribeEventTrackerRequest>
        Model::DescribeEventTrackerOutcomeCallable DescribeEventTrackerCallable(const DescribeEventTrackerRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeEventTracker, request);
        }
 
        template<typename DescribeEventTrackerRequestT = Model::DescribeEventTrackerRequest>
        void DescribeEventTrackerAsync(const DescribeEventTrackerRequestT& request, const DescribeEventTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeEventTracker, request, handler, context);
        }
 
        virtual Model::DescribeFeatureTransformationOutcome DescribeFeatureTransformation(const Model::DescribeFeatureTransformationRequest& request) const;
 
        template<typename DescribeFeatureTransformationRequestT = Model::DescribeFeatureTransformationRequest>
        Model::DescribeFeatureTransformationOutcomeCallable DescribeFeatureTransformationCallable(const DescribeFeatureTransformationRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeFeatureTransformation, request);
        }
 
        template<typename DescribeFeatureTransformationRequestT = Model::DescribeFeatureTransformationRequest>
        void DescribeFeatureTransformationAsync(const DescribeFeatureTransformationRequestT& request, const DescribeFeatureTransformationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeFeatureTransformation, request, handler, context);
        }
 
        virtual Model::DescribeFilterOutcome DescribeFilter(const Model::DescribeFilterRequest& request) const;
 
        template<typename DescribeFilterRequestT = Model::DescribeFilterRequest>
        Model::DescribeFilterOutcomeCallable DescribeFilterCallable(const DescribeFilterRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeFilter, request);
        }
 
        template<typename DescribeFilterRequestT = Model::DescribeFilterRequest>
        void DescribeFilterAsync(const DescribeFilterRequestT& request, const DescribeFilterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeFilter, request, handler, context);
        }
 
        virtual Model::DescribeMetricAttributionOutcome DescribeMetricAttribution(const Model::DescribeMetricAttributionRequest& request) const;
 
        template<typename DescribeMetricAttributionRequestT = Model::DescribeMetricAttributionRequest>
        Model::DescribeMetricAttributionOutcomeCallable DescribeMetricAttributionCallable(const DescribeMetricAttributionRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeMetricAttribution, request);
        }
 
        template<typename DescribeMetricAttributionRequestT = Model::DescribeMetricAttributionRequest>
        void DescribeMetricAttributionAsync(const DescribeMetricAttributionRequestT& request, const DescribeMetricAttributionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeMetricAttribution, request, handler, context);
        }
 
        virtual Model::DescribeRecipeOutcome DescribeRecipe(const Model::DescribeRecipeRequest& request) const;
 
        template<typename DescribeRecipeRequestT = Model::DescribeRecipeRequest>
        Model::DescribeRecipeOutcomeCallable DescribeRecipeCallable(const DescribeRecipeRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeRecipe, request);
        }
 
        template<typename DescribeRecipeRequestT = Model::DescribeRecipeRequest>
        void DescribeRecipeAsync(const DescribeRecipeRequestT& request, const DescribeRecipeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeRecipe, request, handler, context);
        }
 
        virtual Model::DescribeRecommenderOutcome DescribeRecommender(const Model::DescribeRecommenderRequest& request) const;
 
        template<typename DescribeRecommenderRequestT = Model::DescribeRecommenderRequest>
        Model::DescribeRecommenderOutcomeCallable DescribeRecommenderCallable(const DescribeRecommenderRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeRecommender, request);
        }
 
        template<typename DescribeRecommenderRequestT = Model::DescribeRecommenderRequest>
        void DescribeRecommenderAsync(const DescribeRecommenderRequestT& request, const DescribeRecommenderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeRecommender, request, handler, context);
        }
 
        virtual Model::DescribeSchemaOutcome DescribeSchema(const Model::DescribeSchemaRequest& request) const;
 
        template<typename DescribeSchemaRequestT = Model::DescribeSchemaRequest>
        Model::DescribeSchemaOutcomeCallable DescribeSchemaCallable(const DescribeSchemaRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeSchema, request);
        }
 
        template<typename DescribeSchemaRequestT = Model::DescribeSchemaRequest>
        void DescribeSchemaAsync(const DescribeSchemaRequestT& request, const DescribeSchemaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeSchema, request, handler, context);
        }
 
        virtual Model::DescribeSolutionOutcome DescribeSolution(const Model::DescribeSolutionRequest& request) const;
 
        template<typename DescribeSolutionRequestT = Model::DescribeSolutionRequest>
        Model::DescribeSolutionOutcomeCallable DescribeSolutionCallable(const DescribeSolutionRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeSolution, request);
        }
 
        template<typename DescribeSolutionRequestT = Model::DescribeSolutionRequest>
        void DescribeSolutionAsync(const DescribeSolutionRequestT& request, const DescribeSolutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeSolution, request, handler, context);
        }
 
        virtual Model::DescribeSolutionVersionOutcome DescribeSolutionVersion(const Model::DescribeSolutionVersionRequest& request) const;
 
        template<typename DescribeSolutionVersionRequestT = Model::DescribeSolutionVersionRequest>
        Model::DescribeSolutionVersionOutcomeCallable DescribeSolutionVersionCallable(const DescribeSolutionVersionRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::DescribeSolutionVersion, request);
        }
 
        template<typename DescribeSolutionVersionRequestT = Model::DescribeSolutionVersionRequest>
        void DescribeSolutionVersionAsync(const DescribeSolutionVersionRequestT& request, const DescribeSolutionVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::DescribeSolutionVersion, request, handler, context);
        }
 
        virtual Model::GetSolutionMetricsOutcome GetSolutionMetrics(const Model::GetSolutionMetricsRequest& request) const;
 
        template<typename GetSolutionMetricsRequestT = Model::GetSolutionMetricsRequest>
        Model::GetSolutionMetricsOutcomeCallable GetSolutionMetricsCallable(const GetSolutionMetricsRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::GetSolutionMetrics, request);
        }
 
        template<typename GetSolutionMetricsRequestT = Model::GetSolutionMetricsRequest>
        void GetSolutionMetricsAsync(const GetSolutionMetricsRequestT& request, const GetSolutionMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::GetSolutionMetrics, request, handler, context);
        }
 
        virtual Model::ListBatchInferenceJobsOutcome ListBatchInferenceJobs(const Model::ListBatchInferenceJobsRequest& request = {}) const;
 
        template<typename ListBatchInferenceJobsRequestT = Model::ListBatchInferenceJobsRequest>
        Model::ListBatchInferenceJobsOutcomeCallable ListBatchInferenceJobsCallable(const ListBatchInferenceJobsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListBatchInferenceJobs, request);
        }
 
        template<typename ListBatchInferenceJobsRequestT = Model::ListBatchInferenceJobsRequest>
        void ListBatchInferenceJobsAsync(const ListBatchInferenceJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBatchInferenceJobsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListBatchInferenceJobs, request, handler, context);
        }
 
        virtual Model::ListBatchSegmentJobsOutcome ListBatchSegmentJobs(const Model::ListBatchSegmentJobsRequest& request = {}) const;
 
        template<typename ListBatchSegmentJobsRequestT = Model::ListBatchSegmentJobsRequest>
        Model::ListBatchSegmentJobsOutcomeCallable ListBatchSegmentJobsCallable(const ListBatchSegmentJobsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListBatchSegmentJobs, request);
        }
 
        template<typename ListBatchSegmentJobsRequestT = Model::ListBatchSegmentJobsRequest>
        void ListBatchSegmentJobsAsync(const ListBatchSegmentJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBatchSegmentJobsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListBatchSegmentJobs, request, handler, context);
        }
 
        virtual Model::ListCampaignsOutcome ListCampaigns(const Model::ListCampaignsRequest& request = {}) const;
 
        template<typename ListCampaignsRequestT = Model::ListCampaignsRequest>
        Model::ListCampaignsOutcomeCallable ListCampaignsCallable(const ListCampaignsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListCampaigns, request);
        }
 
        template<typename ListCampaignsRequestT = Model::ListCampaignsRequest>
        void ListCampaignsAsync(const ListCampaignsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCampaignsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListCampaigns, request, handler, context);
        }
 
        virtual Model::ListDataDeletionJobsOutcome ListDataDeletionJobs(const Model::ListDataDeletionJobsRequest& request = {}) const;
 
        template<typename ListDataDeletionJobsRequestT = Model::ListDataDeletionJobsRequest>
        Model::ListDataDeletionJobsOutcomeCallable ListDataDeletionJobsCallable(const ListDataDeletionJobsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListDataDeletionJobs, request);
        }
 
        template<typename ListDataDeletionJobsRequestT = Model::ListDataDeletionJobsRequest>
        void ListDataDeletionJobsAsync(const ListDataDeletionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataDeletionJobsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListDataDeletionJobs, request, handler, context);
        }
 
        virtual Model::ListDatasetExportJobsOutcome ListDatasetExportJobs(const Model::ListDatasetExportJobsRequest& request = {}) const;
 
        template<typename ListDatasetExportJobsRequestT = Model::ListDatasetExportJobsRequest>
        Model::ListDatasetExportJobsOutcomeCallable ListDatasetExportJobsCallable(const ListDatasetExportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListDatasetExportJobs, request);
        }
 
        template<typename ListDatasetExportJobsRequestT = Model::ListDatasetExportJobsRequest>
        void ListDatasetExportJobsAsync(const ListDatasetExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatasetExportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListDatasetExportJobs, request, handler, context);
        }
 
        virtual Model::ListDatasetGroupsOutcome ListDatasetGroups(const Model::ListDatasetGroupsRequest& request = {}) const;
 
        template<typename ListDatasetGroupsRequestT = Model::ListDatasetGroupsRequest>
        Model::ListDatasetGroupsOutcomeCallable ListDatasetGroupsCallable(const ListDatasetGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListDatasetGroups, request);
        }
 
        template<typename ListDatasetGroupsRequestT = Model::ListDatasetGroupsRequest>
        void ListDatasetGroupsAsync(const ListDatasetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatasetGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListDatasetGroups, request, handler, context);
        }
 
        virtual Model::ListDatasetImportJobsOutcome ListDatasetImportJobs(const Model::ListDatasetImportJobsRequest& request = {}) const;
 
        template<typename ListDatasetImportJobsRequestT = Model::ListDatasetImportJobsRequest>
        Model::ListDatasetImportJobsOutcomeCallable ListDatasetImportJobsCallable(const ListDatasetImportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListDatasetImportJobs, request);
        }
 
        template<typename ListDatasetImportJobsRequestT = Model::ListDatasetImportJobsRequest>
        void ListDatasetImportJobsAsync(const ListDatasetImportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatasetImportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListDatasetImportJobs, request, handler, context);
        }
 
        virtual Model::ListDatasetsOutcome ListDatasets(const Model::ListDatasetsRequest& request = {}) const;
 
        template<typename ListDatasetsRequestT = Model::ListDatasetsRequest>
        Model::ListDatasetsOutcomeCallable ListDatasetsCallable(const ListDatasetsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListDatasets, request);
        }
 
        template<typename ListDatasetsRequestT = Model::ListDatasetsRequest>
        void ListDatasetsAsync(const ListDatasetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDatasetsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListDatasets, request, handler, context);
        }
 
        virtual Model::ListEventTrackersOutcome ListEventTrackers(const Model::ListEventTrackersRequest& request = {}) const;
 
        template<typename ListEventTrackersRequestT = Model::ListEventTrackersRequest>
        Model::ListEventTrackersOutcomeCallable ListEventTrackersCallable(const ListEventTrackersRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListEventTrackers, request);
        }
 
        template<typename ListEventTrackersRequestT = Model::ListEventTrackersRequest>
        void ListEventTrackersAsync(const ListEventTrackersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEventTrackersRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListEventTrackers, request, handler, context);
        }
 
        virtual Model::ListFiltersOutcome ListFilters(const Model::ListFiltersRequest& request = {}) const;
 
        template<typename ListFiltersRequestT = Model::ListFiltersRequest>
        Model::ListFiltersOutcomeCallable ListFiltersCallable(const ListFiltersRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListFilters, request);
        }
 
        template<typename ListFiltersRequestT = Model::ListFiltersRequest>
        void ListFiltersAsync(const ListFiltersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListFiltersRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListFilters, request, handler, context);
        }
 
        virtual Model::ListMetricAttributionMetricsOutcome ListMetricAttributionMetrics(const Model::ListMetricAttributionMetricsRequest& request = {}) const;
 
        template<typename ListMetricAttributionMetricsRequestT = Model::ListMetricAttributionMetricsRequest>
        Model::ListMetricAttributionMetricsOutcomeCallable ListMetricAttributionMetricsCallable(const ListMetricAttributionMetricsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListMetricAttributionMetrics, request);
        }
 
        template<typename ListMetricAttributionMetricsRequestT = Model::ListMetricAttributionMetricsRequest>
        void ListMetricAttributionMetricsAsync(const ListMetricAttributionMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMetricAttributionMetricsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListMetricAttributionMetrics, request, handler, context);
        }
 
        virtual Model::ListMetricAttributionsOutcome ListMetricAttributions(const Model::ListMetricAttributionsRequest& request = {}) const;
 
        template<typename ListMetricAttributionsRequestT = Model::ListMetricAttributionsRequest>
        Model::ListMetricAttributionsOutcomeCallable ListMetricAttributionsCallable(const ListMetricAttributionsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListMetricAttributions, request);
        }
 
        template<typename ListMetricAttributionsRequestT = Model::ListMetricAttributionsRequest>
        void ListMetricAttributionsAsync(const ListMetricAttributionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMetricAttributionsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListMetricAttributions, request, handler, context);
        }
 
        virtual Model::ListRecipesOutcome ListRecipes(const Model::ListRecipesRequest& request = {}) const;
 
        template<typename ListRecipesRequestT = Model::ListRecipesRequest>
        Model::ListRecipesOutcomeCallable ListRecipesCallable(const ListRecipesRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListRecipes, request);
        }
 
        template<typename ListRecipesRequestT = Model::ListRecipesRequest>
        void ListRecipesAsync(const ListRecipesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRecipesRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListRecipes, request, handler, context);
        }
 
        virtual Model::ListRecommendersOutcome ListRecommenders(const Model::ListRecommendersRequest& request = {}) const;
 
        template<typename ListRecommendersRequestT = Model::ListRecommendersRequest>
        Model::ListRecommendersOutcomeCallable ListRecommendersCallable(const ListRecommendersRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListRecommenders, request);
        }
 
        template<typename ListRecommendersRequestT = Model::ListRecommendersRequest>
        void ListRecommendersAsync(const ListRecommendersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRecommendersRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListRecommenders, request, handler, context);
        }
 
        virtual Model::ListSchemasOutcome ListSchemas(const Model::ListSchemasRequest& request = {}) const;
 
        template<typename ListSchemasRequestT = Model::ListSchemasRequest>
        Model::ListSchemasOutcomeCallable ListSchemasCallable(const ListSchemasRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListSchemas, request);
        }
 
        template<typename ListSchemasRequestT = Model::ListSchemasRequest>
        void ListSchemasAsync(const ListSchemasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSchemasRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListSchemas, request, handler, context);
        }
 
        virtual Model::ListSolutionVersionsOutcome ListSolutionVersions(const Model::ListSolutionVersionsRequest& request = {}) const;
 
        template<typename ListSolutionVersionsRequestT = Model::ListSolutionVersionsRequest>
        Model::ListSolutionVersionsOutcomeCallable ListSolutionVersionsCallable(const ListSolutionVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListSolutionVersions, request);
        }
 
        template<typename ListSolutionVersionsRequestT = Model::ListSolutionVersionsRequest>
        void ListSolutionVersionsAsync(const ListSolutionVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSolutionVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListSolutionVersions, request, handler, context);
        }
 
        virtual Model::ListSolutionsOutcome ListSolutions(const Model::ListSolutionsRequest& request = {}) const;
 
        template<typename ListSolutionsRequestT = Model::ListSolutionsRequest>
        Model::ListSolutionsOutcomeCallable ListSolutionsCallable(const ListSolutionsRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::ListSolutions, request);
        }
 
        template<typename ListSolutionsRequestT = Model::ListSolutionsRequest>
        void ListSolutionsAsync(const ListSolutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSolutionsRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::ListSolutions, 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(&PersonalizeClient::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(&PersonalizeClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::StartRecommenderOutcome StartRecommender(const Model::StartRecommenderRequest& request) const;
 
        template<typename StartRecommenderRequestT = Model::StartRecommenderRequest>
        Model::StartRecommenderOutcomeCallable StartRecommenderCallable(const StartRecommenderRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::StartRecommender, request);
        }
 
        template<typename StartRecommenderRequestT = Model::StartRecommenderRequest>
        void StartRecommenderAsync(const StartRecommenderRequestT& request, const StartRecommenderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::StartRecommender, request, handler, context);
        }
 
        virtual Model::StopRecommenderOutcome StopRecommender(const Model::StopRecommenderRequest& request) const;
 
        template<typename StopRecommenderRequestT = Model::StopRecommenderRequest>
        Model::StopRecommenderOutcomeCallable StopRecommenderCallable(const StopRecommenderRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::StopRecommender, request);
        }
 
        template<typename StopRecommenderRequestT = Model::StopRecommenderRequest>
        void StopRecommenderAsync(const StopRecommenderRequestT& request, const StopRecommenderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::StopRecommender, request, handler, context);
        }
 
        virtual Model::StopSolutionVersionCreationOutcome StopSolutionVersionCreation(const Model::StopSolutionVersionCreationRequest& request) const;
 
        template<typename StopSolutionVersionCreationRequestT = Model::StopSolutionVersionCreationRequest>
        Model::StopSolutionVersionCreationOutcomeCallable StopSolutionVersionCreationCallable(const StopSolutionVersionCreationRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::StopSolutionVersionCreation, request);
        }
 
        template<typename StopSolutionVersionCreationRequestT = Model::StopSolutionVersionCreationRequest>
        void StopSolutionVersionCreationAsync(const StopSolutionVersionCreationRequestT& request, const StopSolutionVersionCreationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::StopSolutionVersionCreation, 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(&PersonalizeClient::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(&PersonalizeClient::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(&PersonalizeClient::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(&PersonalizeClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateCampaignOutcome UpdateCampaign(const Model::UpdateCampaignRequest& request) const;
 
        template<typename UpdateCampaignRequestT = Model::UpdateCampaignRequest>
        Model::UpdateCampaignOutcomeCallable UpdateCampaignCallable(const UpdateCampaignRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::UpdateCampaign, request);
        }
 
        template<typename UpdateCampaignRequestT = Model::UpdateCampaignRequest>
        void UpdateCampaignAsync(const UpdateCampaignRequestT& request, const UpdateCampaignResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::UpdateCampaign, request, handler, context);
        }
 
        virtual Model::UpdateDatasetOutcome UpdateDataset(const Model::UpdateDatasetRequest& request) const;
 
        template<typename UpdateDatasetRequestT = Model::UpdateDatasetRequest>
        Model::UpdateDatasetOutcomeCallable UpdateDatasetCallable(const UpdateDatasetRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::UpdateDataset, request);
        }
 
        template<typename UpdateDatasetRequestT = Model::UpdateDatasetRequest>
        void UpdateDatasetAsync(const UpdateDatasetRequestT& request, const UpdateDatasetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::UpdateDataset, request, handler, context);
        }
 
        virtual Model::UpdateMetricAttributionOutcome UpdateMetricAttribution(const Model::UpdateMetricAttributionRequest& request = {}) const;
 
        template<typename UpdateMetricAttributionRequestT = Model::UpdateMetricAttributionRequest>
        Model::UpdateMetricAttributionOutcomeCallable UpdateMetricAttributionCallable(const UpdateMetricAttributionRequestT& request = {}) const
        {
            return SubmitCallable(&PersonalizeClient::UpdateMetricAttribution, request);
        }
 
        template<typename UpdateMetricAttributionRequestT = Model::UpdateMetricAttributionRequest>
        void UpdateMetricAttributionAsync(const UpdateMetricAttributionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateMetricAttributionRequestT& request = {}) const
        {
            return SubmitAsync(&PersonalizeClient::UpdateMetricAttribution, request, handler, context);
        }
 
        virtual Model::UpdateRecommenderOutcome UpdateRecommender(const Model::UpdateRecommenderRequest& request) const;
 
        template<typename UpdateRecommenderRequestT = Model::UpdateRecommenderRequest>
        Model::UpdateRecommenderOutcomeCallable UpdateRecommenderCallable(const UpdateRecommenderRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::UpdateRecommender, request);
        }
 
        template<typename UpdateRecommenderRequestT = Model::UpdateRecommenderRequest>
        void UpdateRecommenderAsync(const UpdateRecommenderRequestT& request, const UpdateRecommenderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::UpdateRecommender, request, handler, context);
        }
 
        virtual Model::UpdateSolutionOutcome UpdateSolution(const Model::UpdateSolutionRequest& request) const;
 
        template<typename UpdateSolutionRequestT = Model::UpdateSolutionRequest>
        Model::UpdateSolutionOutcomeCallable UpdateSolutionCallable(const UpdateSolutionRequestT& request) const
        {
            return SubmitCallable(&PersonalizeClient::UpdateSolution, request);
        }
 
        template<typename UpdateSolutionRequestT = Model::UpdateSolutionRequest>
        void UpdateSolutionAsync(const UpdateSolutionRequestT& request, const UpdateSolutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&PersonalizeClient::UpdateSolution, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<PersonalizeEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<PersonalizeClient>;
      void init(const PersonalizeClientConfiguration& clientConfiguration);
 
      PersonalizeClientConfiguration m_clientConfiguration;
      std::shared_ptr<PersonalizeEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Personalize
} // namespace Aws