GlueDataBrewClient.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/databrew/GlueDataBrewPaginationBase.h>
#include <aws/databrew/GlueDataBrewServiceClientModel.h>
#include <aws/databrew/GlueDataBrewWaiter.h>
#include <aws/databrew/GlueDataBrew_EXPORTS.h>
 
namespace Aws {
namespace GlueDataBrew {
class AWS_GLUEDATABREW_API GlueDataBrewClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<GlueDataBrewClient>,
                                                public GlueDataBrewPaginationBase<GlueDataBrewClient>,
                                                public GlueDataBrewWaiter<GlueDataBrewClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef GlueDataBrewClientConfiguration ClientConfigurationType;
  typedef GlueDataBrewEndpointProvider EndpointProviderType;
 
  GlueDataBrewClient(
      const Aws::GlueDataBrew::GlueDataBrewClientConfiguration& clientConfiguration = Aws::GlueDataBrew::GlueDataBrewClientConfiguration(),
      std::shared_ptr<GlueDataBrewEndpointProviderBase> endpointProvider = nullptr);
 
  GlueDataBrewClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<GlueDataBrewEndpointProviderBase> endpointProvider = nullptr,
      const Aws::GlueDataBrew::GlueDataBrewClientConfiguration& clientConfiguration = Aws::GlueDataBrew::GlueDataBrewClientConfiguration());
 
  GlueDataBrewClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<GlueDataBrewEndpointProviderBase> endpointProvider = nullptr,
      const Aws::GlueDataBrew::GlueDataBrewClientConfiguration& clientConfiguration = Aws::GlueDataBrew::GlueDataBrewClientConfiguration());
 
  /* Legacy constructors due deprecation */
  GlueDataBrewClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GlueDataBrewClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  GlueDataBrewClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~GlueDataBrewClient();
 
  virtual Model::BatchDeleteRecipeVersionOutcome BatchDeleteRecipeVersion(const Model::BatchDeleteRecipeVersionRequest& request) const;
 
  template <typename BatchDeleteRecipeVersionRequestT = Model::BatchDeleteRecipeVersionRequest>
  Model::BatchDeleteRecipeVersionOutcomeCallable BatchDeleteRecipeVersionCallable(const BatchDeleteRecipeVersionRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::BatchDeleteRecipeVersion, request);
  }
 
  template <typename BatchDeleteRecipeVersionRequestT = Model::BatchDeleteRecipeVersionRequest>
  void BatchDeleteRecipeVersionAsync(const BatchDeleteRecipeVersionRequestT& request,
                                     const BatchDeleteRecipeVersionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::BatchDeleteRecipeVersion, 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(&GlueDataBrewClient::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(&GlueDataBrewClient::CreateDataset, request, handler, context);
  }
 
  virtual Model::CreateProfileJobOutcome CreateProfileJob(const Model::CreateProfileJobRequest& request) const;
 
  template <typename CreateProfileJobRequestT = Model::CreateProfileJobRequest>
  Model::CreateProfileJobOutcomeCallable CreateProfileJobCallable(const CreateProfileJobRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::CreateProfileJob, request);
  }
 
  template <typename CreateProfileJobRequestT = Model::CreateProfileJobRequest>
  void CreateProfileJobAsync(const CreateProfileJobRequestT& request, const CreateProfileJobResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::CreateProfileJob, request, handler, context);
  }
 
  virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const;
 
  template <typename CreateProjectRequestT = Model::CreateProjectRequest>
  Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::CreateProject, request);
  }
 
  template <typename CreateProjectRequestT = Model::CreateProjectRequest>
  void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::CreateProject, request, handler, context);
  }
 
  virtual Model::CreateRecipeOutcome CreateRecipe(const Model::CreateRecipeRequest& request) const;
 
  template <typename CreateRecipeRequestT = Model::CreateRecipeRequest>
  Model::CreateRecipeOutcomeCallable CreateRecipeCallable(const CreateRecipeRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::CreateRecipe, request);
  }
 
  template <typename CreateRecipeRequestT = Model::CreateRecipeRequest>
  void CreateRecipeAsync(const CreateRecipeRequestT& request, const CreateRecipeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::CreateRecipe, request, handler, context);
  }
 
  virtual Model::CreateRecipeJobOutcome CreateRecipeJob(const Model::CreateRecipeJobRequest& request) const;
 
  template <typename CreateRecipeJobRequestT = Model::CreateRecipeJobRequest>
  Model::CreateRecipeJobOutcomeCallable CreateRecipeJobCallable(const CreateRecipeJobRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::CreateRecipeJob, request);
  }
 
  template <typename CreateRecipeJobRequestT = Model::CreateRecipeJobRequest>
  void CreateRecipeJobAsync(const CreateRecipeJobRequestT& request, const CreateRecipeJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::CreateRecipeJob, request, handler, context);
  }
 
  virtual Model::CreateRulesetOutcome CreateRuleset(const Model::CreateRulesetRequest& request) const;
 
  template <typename CreateRulesetRequestT = Model::CreateRulesetRequest>
  Model::CreateRulesetOutcomeCallable CreateRulesetCallable(const CreateRulesetRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::CreateRuleset, request);
  }
 
  template <typename CreateRulesetRequestT = Model::CreateRulesetRequest>
  void CreateRulesetAsync(const CreateRulesetRequestT& request, const CreateRulesetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::CreateRuleset, request, handler, context);
  }
 
  virtual Model::CreateScheduleOutcome CreateSchedule(const Model::CreateScheduleRequest& request) const;
 
  template <typename CreateScheduleRequestT = Model::CreateScheduleRequest>
  Model::CreateScheduleOutcomeCallable CreateScheduleCallable(const CreateScheduleRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::CreateSchedule, request);
  }
 
  template <typename CreateScheduleRequestT = Model::CreateScheduleRequest>
  void CreateScheduleAsync(const CreateScheduleRequestT& request, const CreateScheduleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::CreateSchedule, 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(&GlueDataBrewClient::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(&GlueDataBrewClient::DeleteDataset, request, handler, context);
  }
 
  virtual Model::DeleteJobOutcome DeleteJob(const Model::DeleteJobRequest& request) const;
 
  template <typename DeleteJobRequestT = Model::DeleteJobRequest>
  Model::DeleteJobOutcomeCallable DeleteJobCallable(const DeleteJobRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::DeleteJob, request);
  }
 
  template <typename DeleteJobRequestT = Model::DeleteJobRequest>
  void DeleteJobAsync(const DeleteJobRequestT& request, const DeleteJobResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::DeleteJob, request, handler, context);
  }
 
  virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const;
 
  template <typename DeleteProjectRequestT = Model::DeleteProjectRequest>
  Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::DeleteProject, request);
  }
 
  template <typename DeleteProjectRequestT = Model::DeleteProjectRequest>
  void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::DeleteProject, request, handler, context);
  }
 
  virtual Model::DeleteRecipeVersionOutcome DeleteRecipeVersion(const Model::DeleteRecipeVersionRequest& request) const;
 
  template <typename DeleteRecipeVersionRequestT = Model::DeleteRecipeVersionRequest>
  Model::DeleteRecipeVersionOutcomeCallable DeleteRecipeVersionCallable(const DeleteRecipeVersionRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::DeleteRecipeVersion, request);
  }
 
  template <typename DeleteRecipeVersionRequestT = Model::DeleteRecipeVersionRequest>
  void DeleteRecipeVersionAsync(const DeleteRecipeVersionRequestT& request, const DeleteRecipeVersionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::DeleteRecipeVersion, request, handler, context);
  }
 
  virtual Model::DeleteRulesetOutcome DeleteRuleset(const Model::DeleteRulesetRequest& request) const;
 
  template <typename DeleteRulesetRequestT = Model::DeleteRulesetRequest>
  Model::DeleteRulesetOutcomeCallable DeleteRulesetCallable(const DeleteRulesetRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::DeleteRuleset, request);
  }
 
  template <typename DeleteRulesetRequestT = Model::DeleteRulesetRequest>
  void DeleteRulesetAsync(const DeleteRulesetRequestT& request, const DeleteRulesetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::DeleteRuleset, request, handler, context);
  }
 
  virtual Model::DeleteScheduleOutcome DeleteSchedule(const Model::DeleteScheduleRequest& request) const;
 
  template <typename DeleteScheduleRequestT = Model::DeleteScheduleRequest>
  Model::DeleteScheduleOutcomeCallable DeleteScheduleCallable(const DeleteScheduleRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::DeleteSchedule, request);
  }
 
  template <typename DeleteScheduleRequestT = Model::DeleteScheduleRequest>
  void DeleteScheduleAsync(const DeleteScheduleRequestT& request, const DeleteScheduleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::DeleteSchedule, 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(&GlueDataBrewClient::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(&GlueDataBrewClient::DescribeDataset, request, handler, context);
  }
 
  virtual Model::DescribeJobOutcome DescribeJob(const Model::DescribeJobRequest& request) const;
 
  template <typename DescribeJobRequestT = Model::DescribeJobRequest>
  Model::DescribeJobOutcomeCallable DescribeJobCallable(const DescribeJobRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::DescribeJob, request);
  }
 
  template <typename DescribeJobRequestT = Model::DescribeJobRequest>
  void DescribeJobAsync(const DescribeJobRequestT& request, const DescribeJobResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::DescribeJob, request, handler, context);
  }
 
  virtual Model::DescribeJobRunOutcome DescribeJobRun(const Model::DescribeJobRunRequest& request) const;
 
  template <typename DescribeJobRunRequestT = Model::DescribeJobRunRequest>
  Model::DescribeJobRunOutcomeCallable DescribeJobRunCallable(const DescribeJobRunRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::DescribeJobRun, request);
  }
 
  template <typename DescribeJobRunRequestT = Model::DescribeJobRunRequest>
  void DescribeJobRunAsync(const DescribeJobRunRequestT& request, const DescribeJobRunResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::DescribeJobRun, request, handler, context);
  }
 
  virtual Model::DescribeProjectOutcome DescribeProject(const Model::DescribeProjectRequest& request) const;
 
  template <typename DescribeProjectRequestT = Model::DescribeProjectRequest>
  Model::DescribeProjectOutcomeCallable DescribeProjectCallable(const DescribeProjectRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::DescribeProject, request);
  }
 
  template <typename DescribeProjectRequestT = Model::DescribeProjectRequest>
  void DescribeProjectAsync(const DescribeProjectRequestT& request, const DescribeProjectResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::DescribeProject, 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(&GlueDataBrewClient::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(&GlueDataBrewClient::DescribeRecipe, request, handler, context);
  }
 
  virtual Model::DescribeRulesetOutcome DescribeRuleset(const Model::DescribeRulesetRequest& request) const;
 
  template <typename DescribeRulesetRequestT = Model::DescribeRulesetRequest>
  Model::DescribeRulesetOutcomeCallable DescribeRulesetCallable(const DescribeRulesetRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::DescribeRuleset, request);
  }
 
  template <typename DescribeRulesetRequestT = Model::DescribeRulesetRequest>
  void DescribeRulesetAsync(const DescribeRulesetRequestT& request, const DescribeRulesetResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::DescribeRuleset, request, handler, context);
  }
 
  virtual Model::DescribeScheduleOutcome DescribeSchedule(const Model::DescribeScheduleRequest& request) const;
 
  template <typename DescribeScheduleRequestT = Model::DescribeScheduleRequest>
  Model::DescribeScheduleOutcomeCallable DescribeScheduleCallable(const DescribeScheduleRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::DescribeSchedule, request);
  }
 
  template <typename DescribeScheduleRequestT = Model::DescribeScheduleRequest>
  void DescribeScheduleAsync(const DescribeScheduleRequestT& request, const DescribeScheduleResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::DescribeSchedule, 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(&GlueDataBrewClient::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(&GlueDataBrewClient::ListDatasets, request, handler, context);
  }
 
  virtual Model::ListJobRunsOutcome ListJobRuns(const Model::ListJobRunsRequest& request) const;
 
  template <typename ListJobRunsRequestT = Model::ListJobRunsRequest>
  Model::ListJobRunsOutcomeCallable ListJobRunsCallable(const ListJobRunsRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::ListJobRuns, request);
  }
 
  template <typename ListJobRunsRequestT = Model::ListJobRunsRequest>
  void ListJobRunsAsync(const ListJobRunsRequestT& request, const ListJobRunsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::ListJobRuns, request, handler, context);
  }
 
  virtual Model::ListJobsOutcome ListJobs(const Model::ListJobsRequest& request = {}) const;
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  Model::ListJobsOutcomeCallable ListJobsCallable(const ListJobsRequestT& request = {}) const {
    return SubmitCallable(&GlueDataBrewClient::ListJobs, request);
  }
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  void ListJobsAsync(const ListJobsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListJobsRequestT& request = {}) const {
    return SubmitAsync(&GlueDataBrewClient::ListJobs, request, handler, context);
  }
 
  virtual Model::ListProjectsOutcome ListProjects(const Model::ListProjectsRequest& request = {}) const;
 
  template <typename ListProjectsRequestT = Model::ListProjectsRequest>
  Model::ListProjectsOutcomeCallable ListProjectsCallable(const ListProjectsRequestT& request = {}) const {
    return SubmitCallable(&GlueDataBrewClient::ListProjects, request);
  }
 
  template <typename ListProjectsRequestT = Model::ListProjectsRequest>
  void ListProjectsAsync(const ListProjectsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListProjectsRequestT& request = {}) const {
    return SubmitAsync(&GlueDataBrewClient::ListProjects, request, handler, context);
  }
 
  virtual Model::ListRecipeVersionsOutcome ListRecipeVersions(const Model::ListRecipeVersionsRequest& request) const;
 
  template <typename ListRecipeVersionsRequestT = Model::ListRecipeVersionsRequest>
  Model::ListRecipeVersionsOutcomeCallable ListRecipeVersionsCallable(const ListRecipeVersionsRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::ListRecipeVersions, request);
  }
 
  template <typename ListRecipeVersionsRequestT = Model::ListRecipeVersionsRequest>
  void ListRecipeVersionsAsync(const ListRecipeVersionsRequestT& request, const ListRecipeVersionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::ListRecipeVersions, 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(&GlueDataBrewClient::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(&GlueDataBrewClient::ListRecipes, request, handler, context);
  }
 
  virtual Model::ListRulesetsOutcome ListRulesets(const Model::ListRulesetsRequest& request = {}) const;
 
  template <typename ListRulesetsRequestT = Model::ListRulesetsRequest>
  Model::ListRulesetsOutcomeCallable ListRulesetsCallable(const ListRulesetsRequestT& request = {}) const {
    return SubmitCallable(&GlueDataBrewClient::ListRulesets, request);
  }
 
  template <typename ListRulesetsRequestT = Model::ListRulesetsRequest>
  void ListRulesetsAsync(const ListRulesetsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListRulesetsRequestT& request = {}) const {
    return SubmitAsync(&GlueDataBrewClient::ListRulesets, request, handler, context);
  }
 
  virtual Model::ListSchedulesOutcome ListSchedules(const Model::ListSchedulesRequest& request = {}) const;
 
  template <typename ListSchedulesRequestT = Model::ListSchedulesRequest>
  Model::ListSchedulesOutcomeCallable ListSchedulesCallable(const ListSchedulesRequestT& request = {}) const {
    return SubmitCallable(&GlueDataBrewClient::ListSchedules, request);
  }
 
  template <typename ListSchedulesRequestT = Model::ListSchedulesRequest>
  void ListSchedulesAsync(const ListSchedulesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListSchedulesRequestT& request = {}) const {
    return SubmitAsync(&GlueDataBrewClient::ListSchedules, 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(&GlueDataBrewClient::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(&GlueDataBrewClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PublishRecipeOutcome PublishRecipe(const Model::PublishRecipeRequest& request) const;
 
  template <typename PublishRecipeRequestT = Model::PublishRecipeRequest>
  Model::PublishRecipeOutcomeCallable PublishRecipeCallable(const PublishRecipeRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::PublishRecipe, request);
  }
 
  template <typename PublishRecipeRequestT = Model::PublishRecipeRequest>
  void PublishRecipeAsync(const PublishRecipeRequestT& request, const PublishRecipeResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::PublishRecipe, request, handler, context);
  }
 
  virtual Model::SendProjectSessionActionOutcome SendProjectSessionAction(const Model::SendProjectSessionActionRequest& request) const;
 
  template <typename SendProjectSessionActionRequestT = Model::SendProjectSessionActionRequest>
  Model::SendProjectSessionActionOutcomeCallable SendProjectSessionActionCallable(const SendProjectSessionActionRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::SendProjectSessionAction, request);
  }
 
  template <typename SendProjectSessionActionRequestT = Model::SendProjectSessionActionRequest>
  void SendProjectSessionActionAsync(const SendProjectSessionActionRequestT& request,
                                     const SendProjectSessionActionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::SendProjectSessionAction, request, handler, context);
  }
 
  virtual Model::StartJobRunOutcome StartJobRun(const Model::StartJobRunRequest& request) const;
 
  template <typename StartJobRunRequestT = Model::StartJobRunRequest>
  Model::StartJobRunOutcomeCallable StartJobRunCallable(const StartJobRunRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::StartJobRun, request);
  }
 
  template <typename StartJobRunRequestT = Model::StartJobRunRequest>
  void StartJobRunAsync(const StartJobRunRequestT& request, const StartJobRunResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::StartJobRun, request, handler, context);
  }
 
  virtual Model::StartProjectSessionOutcome StartProjectSession(const Model::StartProjectSessionRequest& request) const;
 
  template <typename StartProjectSessionRequestT = Model::StartProjectSessionRequest>
  Model::StartProjectSessionOutcomeCallable StartProjectSessionCallable(const StartProjectSessionRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::StartProjectSession, request);
  }
 
  template <typename StartProjectSessionRequestT = Model::StartProjectSessionRequest>
  void StartProjectSessionAsync(const StartProjectSessionRequestT& request, const StartProjectSessionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::StartProjectSession, request, handler, context);
  }
 
  virtual Model::StopJobRunOutcome StopJobRun(const Model::StopJobRunRequest& request) const;
 
  template <typename StopJobRunRequestT = Model::StopJobRunRequest>
  Model::StopJobRunOutcomeCallable StopJobRunCallable(const StopJobRunRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::StopJobRun, request);
  }
 
  template <typename StopJobRunRequestT = Model::StopJobRunRequest>
  void StopJobRunAsync(const StopJobRunRequestT& request, const StopJobRunResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::StopJobRun, 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(&GlueDataBrewClient::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(&GlueDataBrewClient::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(&GlueDataBrewClient::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(&GlueDataBrewClient::UntagResource, 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(&GlueDataBrewClient::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(&GlueDataBrewClient::UpdateDataset, request, handler, context);
  }
 
  virtual Model::UpdateProfileJobOutcome UpdateProfileJob(const Model::UpdateProfileJobRequest& request) const;
 
  template <typename UpdateProfileJobRequestT = Model::UpdateProfileJobRequest>
  Model::UpdateProfileJobOutcomeCallable UpdateProfileJobCallable(const UpdateProfileJobRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::UpdateProfileJob, request);
  }
 
  template <typename UpdateProfileJobRequestT = Model::UpdateProfileJobRequest>
  void UpdateProfileJobAsync(const UpdateProfileJobRequestT& request, const UpdateProfileJobResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::UpdateProfileJob, request, handler, context);
  }
 
  virtual Model::UpdateProjectOutcome UpdateProject(const Model::UpdateProjectRequest& request) const;
 
  template <typename UpdateProjectRequestT = Model::UpdateProjectRequest>
  Model::UpdateProjectOutcomeCallable UpdateProjectCallable(const UpdateProjectRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::UpdateProject, request);
  }
 
  template <typename UpdateProjectRequestT = Model::UpdateProjectRequest>
  void UpdateProjectAsync(const UpdateProjectRequestT& request, const UpdateProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::UpdateProject, request, handler, context);
  }
 
  virtual Model::UpdateRecipeOutcome UpdateRecipe(const Model::UpdateRecipeRequest& request) const;
 
  template <typename UpdateRecipeRequestT = Model::UpdateRecipeRequest>
  Model::UpdateRecipeOutcomeCallable UpdateRecipeCallable(const UpdateRecipeRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::UpdateRecipe, request);
  }
 
  template <typename UpdateRecipeRequestT = Model::UpdateRecipeRequest>
  void UpdateRecipeAsync(const UpdateRecipeRequestT& request, const UpdateRecipeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::UpdateRecipe, request, handler, context);
  }
 
  virtual Model::UpdateRecipeJobOutcome UpdateRecipeJob(const Model::UpdateRecipeJobRequest& request) const;
 
  template <typename UpdateRecipeJobRequestT = Model::UpdateRecipeJobRequest>
  Model::UpdateRecipeJobOutcomeCallable UpdateRecipeJobCallable(const UpdateRecipeJobRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::UpdateRecipeJob, request);
  }
 
  template <typename UpdateRecipeJobRequestT = Model::UpdateRecipeJobRequest>
  void UpdateRecipeJobAsync(const UpdateRecipeJobRequestT& request, const UpdateRecipeJobResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::UpdateRecipeJob, request, handler, context);
  }
 
  virtual Model::UpdateRulesetOutcome UpdateRuleset(const Model::UpdateRulesetRequest& request) const;
 
  template <typename UpdateRulesetRequestT = Model::UpdateRulesetRequest>
  Model::UpdateRulesetOutcomeCallable UpdateRulesetCallable(const UpdateRulesetRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::UpdateRuleset, request);
  }
 
  template <typename UpdateRulesetRequestT = Model::UpdateRulesetRequest>
  void UpdateRulesetAsync(const UpdateRulesetRequestT& request, const UpdateRulesetResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::UpdateRuleset, request, handler, context);
  }
 
  virtual Model::UpdateScheduleOutcome UpdateSchedule(const Model::UpdateScheduleRequest& request) const;
 
  template <typename UpdateScheduleRequestT = Model::UpdateScheduleRequest>
  Model::UpdateScheduleOutcomeCallable UpdateScheduleCallable(const UpdateScheduleRequestT& request) const {
    return SubmitCallable(&GlueDataBrewClient::UpdateSchedule, request);
  }
 
  template <typename UpdateScheduleRequestT = Model::UpdateScheduleRequest>
  void UpdateScheduleAsync(const UpdateScheduleRequestT& request, const UpdateScheduleResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueDataBrewClient::UpdateSchedule, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GlueDataBrewEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GlueDataBrewClient>;
  void init(const GlueDataBrewClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, GlueDataBrewError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  GlueDataBrewClientConfiguration m_clientConfiguration;
  std::shared_ptr<GlueDataBrewEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace GlueDataBrew
}  // namespace Aws