PersonalizeClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/personalize/PersonalizePaginationBase.h>
#include <aws/personalize/PersonalizeServiceClientModel.h>
#include <aws/personalize/PersonalizeWaiter.h>
#include <aws/personalize/Personalize_EXPORTS.h>
 
namespace Aws {
namespace Personalize {
class AWS_PERSONALIZE_API PersonalizeClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<PersonalizeClient>,
                                              public PersonalizePaginationBase<PersonalizeClient>,
                                              public PersonalizeWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PersonalizeEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PersonalizeClient>;
  void init(const PersonalizeClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, PersonalizeError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  PersonalizeClientConfiguration m_clientConfiguration;
  std::shared_ptr<PersonalizeEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Personalize
}  // namespace Aws