GlueDataBrewClient.h

 
#pragma once
#include <aws/databrew/GlueDataBrew_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/databrew/GlueDataBrewServiceClientModel.h>
 
namespace Aws
{
namespace GlueDataBrew
{
  class AWS_GLUEDATABREW_API GlueDataBrewClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<GlueDataBrewEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<GlueDataBrewClient>;
      void init(const GlueDataBrewClientConfiguration& clientConfiguration);
 
      GlueDataBrewClientConfiguration m_clientConfiguration;
      std::shared_ptr<GlueDataBrewEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace GlueDataBrew
} // namespace Aws