GlueClient.h

 
#pragma once
#include <aws/glue/Glue_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/glue/GlueServiceClientModel.h>
 
namespace Aws
{
namespace Glue
{
  class AWS_GLUE_API GlueClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<GlueClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef GlueClientConfiguration ClientConfigurationType;
      typedef GlueEndpointProvider EndpointProviderType;
 
        GlueClient(const Aws::Glue::GlueClientConfiguration& clientConfiguration = Aws::Glue::GlueClientConfiguration(),
                   std::shared_ptr<GlueEndpointProviderBase> endpointProvider = nullptr);
 
        GlueClient(const Aws::Auth::AWSCredentials& credentials,
                   std::shared_ptr<GlueEndpointProviderBase> endpointProvider = nullptr,
                   const Aws::Glue::GlueClientConfiguration& clientConfiguration = Aws::Glue::GlueClientConfiguration());
 
        GlueClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   std::shared_ptr<GlueEndpointProviderBase> endpointProvider = nullptr,
                   const Aws::Glue::GlueClientConfiguration& clientConfiguration = Aws::Glue::GlueClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        GlueClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        GlueClient(const Aws::Auth::AWSCredentials& credentials,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
        GlueClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~GlueClient();
 
        virtual Model::BatchCreatePartitionOutcome BatchCreatePartition(const Model::BatchCreatePartitionRequest& request) const;
 
        template<typename BatchCreatePartitionRequestT = Model::BatchCreatePartitionRequest>
        Model::BatchCreatePartitionOutcomeCallable BatchCreatePartitionCallable(const BatchCreatePartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchCreatePartition, request);
        }
 
        template<typename BatchCreatePartitionRequestT = Model::BatchCreatePartitionRequest>
        void BatchCreatePartitionAsync(const BatchCreatePartitionRequestT& request, const BatchCreatePartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchCreatePartition, request, handler, context);
        }
 
        virtual Model::BatchDeleteConnectionOutcome BatchDeleteConnection(const Model::BatchDeleteConnectionRequest& request) const;
 
        template<typename BatchDeleteConnectionRequestT = Model::BatchDeleteConnectionRequest>
        Model::BatchDeleteConnectionOutcomeCallable BatchDeleteConnectionCallable(const BatchDeleteConnectionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchDeleteConnection, request);
        }
 
        template<typename BatchDeleteConnectionRequestT = Model::BatchDeleteConnectionRequest>
        void BatchDeleteConnectionAsync(const BatchDeleteConnectionRequestT& request, const BatchDeleteConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchDeleteConnection, request, handler, context);
        }
 
        virtual Model::BatchDeletePartitionOutcome BatchDeletePartition(const Model::BatchDeletePartitionRequest& request) const;
 
        template<typename BatchDeletePartitionRequestT = Model::BatchDeletePartitionRequest>
        Model::BatchDeletePartitionOutcomeCallable BatchDeletePartitionCallable(const BatchDeletePartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchDeletePartition, request);
        }
 
        template<typename BatchDeletePartitionRequestT = Model::BatchDeletePartitionRequest>
        void BatchDeletePartitionAsync(const BatchDeletePartitionRequestT& request, const BatchDeletePartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchDeletePartition, request, handler, context);
        }
 
        virtual Model::BatchDeleteTableOutcome BatchDeleteTable(const Model::BatchDeleteTableRequest& request) const;
 
        template<typename BatchDeleteTableRequestT = Model::BatchDeleteTableRequest>
        Model::BatchDeleteTableOutcomeCallable BatchDeleteTableCallable(const BatchDeleteTableRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchDeleteTable, request);
        }
 
        template<typename BatchDeleteTableRequestT = Model::BatchDeleteTableRequest>
        void BatchDeleteTableAsync(const BatchDeleteTableRequestT& request, const BatchDeleteTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchDeleteTable, request, handler, context);
        }
 
        virtual Model::BatchDeleteTableVersionOutcome BatchDeleteTableVersion(const Model::BatchDeleteTableVersionRequest& request) const;
 
        template<typename BatchDeleteTableVersionRequestT = Model::BatchDeleteTableVersionRequest>
        Model::BatchDeleteTableVersionOutcomeCallable BatchDeleteTableVersionCallable(const BatchDeleteTableVersionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchDeleteTableVersion, request);
        }
 
        template<typename BatchDeleteTableVersionRequestT = Model::BatchDeleteTableVersionRequest>
        void BatchDeleteTableVersionAsync(const BatchDeleteTableVersionRequestT& request, const BatchDeleteTableVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchDeleteTableVersion, request, handler, context);
        }
 
        virtual Model::BatchGetBlueprintsOutcome BatchGetBlueprints(const Model::BatchGetBlueprintsRequest& request) const;
 
        template<typename BatchGetBlueprintsRequestT = Model::BatchGetBlueprintsRequest>
        Model::BatchGetBlueprintsOutcomeCallable BatchGetBlueprintsCallable(const BatchGetBlueprintsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchGetBlueprints, request);
        }
 
        template<typename BatchGetBlueprintsRequestT = Model::BatchGetBlueprintsRequest>
        void BatchGetBlueprintsAsync(const BatchGetBlueprintsRequestT& request, const BatchGetBlueprintsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchGetBlueprints, request, handler, context);
        }
 
        virtual Model::BatchGetCrawlersOutcome BatchGetCrawlers(const Model::BatchGetCrawlersRequest& request) const;
 
        template<typename BatchGetCrawlersRequestT = Model::BatchGetCrawlersRequest>
        Model::BatchGetCrawlersOutcomeCallable BatchGetCrawlersCallable(const BatchGetCrawlersRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchGetCrawlers, request);
        }
 
        template<typename BatchGetCrawlersRequestT = Model::BatchGetCrawlersRequest>
        void BatchGetCrawlersAsync(const BatchGetCrawlersRequestT& request, const BatchGetCrawlersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchGetCrawlers, request, handler, context);
        }
 
        virtual Model::BatchGetCustomEntityTypesOutcome BatchGetCustomEntityTypes(const Model::BatchGetCustomEntityTypesRequest& request) const;
 
        template<typename BatchGetCustomEntityTypesRequestT = Model::BatchGetCustomEntityTypesRequest>
        Model::BatchGetCustomEntityTypesOutcomeCallable BatchGetCustomEntityTypesCallable(const BatchGetCustomEntityTypesRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchGetCustomEntityTypes, request);
        }
 
        template<typename BatchGetCustomEntityTypesRequestT = Model::BatchGetCustomEntityTypesRequest>
        void BatchGetCustomEntityTypesAsync(const BatchGetCustomEntityTypesRequestT& request, const BatchGetCustomEntityTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchGetCustomEntityTypes, request, handler, context);
        }
 
        virtual Model::BatchGetDataQualityResultOutcome BatchGetDataQualityResult(const Model::BatchGetDataQualityResultRequest& request) const;
 
        template<typename BatchGetDataQualityResultRequestT = Model::BatchGetDataQualityResultRequest>
        Model::BatchGetDataQualityResultOutcomeCallable BatchGetDataQualityResultCallable(const BatchGetDataQualityResultRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchGetDataQualityResult, request);
        }
 
        template<typename BatchGetDataQualityResultRequestT = Model::BatchGetDataQualityResultRequest>
        void BatchGetDataQualityResultAsync(const BatchGetDataQualityResultRequestT& request, const BatchGetDataQualityResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchGetDataQualityResult, request, handler, context);
        }
 
        virtual Model::BatchGetDevEndpointsOutcome BatchGetDevEndpoints(const Model::BatchGetDevEndpointsRequest& request) const;
 
        template<typename BatchGetDevEndpointsRequestT = Model::BatchGetDevEndpointsRequest>
        Model::BatchGetDevEndpointsOutcomeCallable BatchGetDevEndpointsCallable(const BatchGetDevEndpointsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchGetDevEndpoints, request);
        }
 
        template<typename BatchGetDevEndpointsRequestT = Model::BatchGetDevEndpointsRequest>
        void BatchGetDevEndpointsAsync(const BatchGetDevEndpointsRequestT& request, const BatchGetDevEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchGetDevEndpoints, request, handler, context);
        }
 
        virtual Model::BatchGetJobsOutcome BatchGetJobs(const Model::BatchGetJobsRequest& request) const;
 
        template<typename BatchGetJobsRequestT = Model::BatchGetJobsRequest>
        Model::BatchGetJobsOutcomeCallable BatchGetJobsCallable(const BatchGetJobsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchGetJobs, request);
        }
 
        template<typename BatchGetJobsRequestT = Model::BatchGetJobsRequest>
        void BatchGetJobsAsync(const BatchGetJobsRequestT& request, const BatchGetJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchGetJobs, request, handler, context);
        }
 
        virtual Model::BatchGetPartitionOutcome BatchGetPartition(const Model::BatchGetPartitionRequest& request) const;
 
        template<typename BatchGetPartitionRequestT = Model::BatchGetPartitionRequest>
        Model::BatchGetPartitionOutcomeCallable BatchGetPartitionCallable(const BatchGetPartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchGetPartition, request);
        }
 
        template<typename BatchGetPartitionRequestT = Model::BatchGetPartitionRequest>
        void BatchGetPartitionAsync(const BatchGetPartitionRequestT& request, const BatchGetPartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchGetPartition, request, handler, context);
        }
 
        virtual Model::BatchGetTableOptimizerOutcome BatchGetTableOptimizer(const Model::BatchGetTableOptimizerRequest& request) const;
 
        template<typename BatchGetTableOptimizerRequestT = Model::BatchGetTableOptimizerRequest>
        Model::BatchGetTableOptimizerOutcomeCallable BatchGetTableOptimizerCallable(const BatchGetTableOptimizerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchGetTableOptimizer, request);
        }
 
        template<typename BatchGetTableOptimizerRequestT = Model::BatchGetTableOptimizerRequest>
        void BatchGetTableOptimizerAsync(const BatchGetTableOptimizerRequestT& request, const BatchGetTableOptimizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchGetTableOptimizer, request, handler, context);
        }
 
        virtual Model::BatchGetTriggersOutcome BatchGetTriggers(const Model::BatchGetTriggersRequest& request) const;
 
        template<typename BatchGetTriggersRequestT = Model::BatchGetTriggersRequest>
        Model::BatchGetTriggersOutcomeCallable BatchGetTriggersCallable(const BatchGetTriggersRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchGetTriggers, request);
        }
 
        template<typename BatchGetTriggersRequestT = Model::BatchGetTriggersRequest>
        void BatchGetTriggersAsync(const BatchGetTriggersRequestT& request, const BatchGetTriggersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchGetTriggers, request, handler, context);
        }
 
        virtual Model::BatchGetWorkflowsOutcome BatchGetWorkflows(const Model::BatchGetWorkflowsRequest& request) const;
 
        template<typename BatchGetWorkflowsRequestT = Model::BatchGetWorkflowsRequest>
        Model::BatchGetWorkflowsOutcomeCallable BatchGetWorkflowsCallable(const BatchGetWorkflowsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchGetWorkflows, request);
        }
 
        template<typename BatchGetWorkflowsRequestT = Model::BatchGetWorkflowsRequest>
        void BatchGetWorkflowsAsync(const BatchGetWorkflowsRequestT& request, const BatchGetWorkflowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchGetWorkflows, request, handler, context);
        }
 
        virtual Model::BatchPutDataQualityStatisticAnnotationOutcome BatchPutDataQualityStatisticAnnotation(const Model::BatchPutDataQualityStatisticAnnotationRequest& request) const;
 
        template<typename BatchPutDataQualityStatisticAnnotationRequestT = Model::BatchPutDataQualityStatisticAnnotationRequest>
        Model::BatchPutDataQualityStatisticAnnotationOutcomeCallable BatchPutDataQualityStatisticAnnotationCallable(const BatchPutDataQualityStatisticAnnotationRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchPutDataQualityStatisticAnnotation, request);
        }
 
        template<typename BatchPutDataQualityStatisticAnnotationRequestT = Model::BatchPutDataQualityStatisticAnnotationRequest>
        void BatchPutDataQualityStatisticAnnotationAsync(const BatchPutDataQualityStatisticAnnotationRequestT& request, const BatchPutDataQualityStatisticAnnotationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchPutDataQualityStatisticAnnotation, request, handler, context);
        }
 
        virtual Model::BatchStopJobRunOutcome BatchStopJobRun(const Model::BatchStopJobRunRequest& request) const;
 
        template<typename BatchStopJobRunRequestT = Model::BatchStopJobRunRequest>
        Model::BatchStopJobRunOutcomeCallable BatchStopJobRunCallable(const BatchStopJobRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchStopJobRun, request);
        }
 
        template<typename BatchStopJobRunRequestT = Model::BatchStopJobRunRequest>
        void BatchStopJobRunAsync(const BatchStopJobRunRequestT& request, const BatchStopJobRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchStopJobRun, request, handler, context);
        }
 
        virtual Model::BatchUpdatePartitionOutcome BatchUpdatePartition(const Model::BatchUpdatePartitionRequest& request) const;
 
        template<typename BatchUpdatePartitionRequestT = Model::BatchUpdatePartitionRequest>
        Model::BatchUpdatePartitionOutcomeCallable BatchUpdatePartitionCallable(const BatchUpdatePartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::BatchUpdatePartition, request);
        }
 
        template<typename BatchUpdatePartitionRequestT = Model::BatchUpdatePartitionRequest>
        void BatchUpdatePartitionAsync(const BatchUpdatePartitionRequestT& request, const BatchUpdatePartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::BatchUpdatePartition, request, handler, context);
        }
 
        virtual Model::CancelDataQualityRuleRecommendationRunOutcome CancelDataQualityRuleRecommendationRun(const Model::CancelDataQualityRuleRecommendationRunRequest& request) const;
 
        template<typename CancelDataQualityRuleRecommendationRunRequestT = Model::CancelDataQualityRuleRecommendationRunRequest>
        Model::CancelDataQualityRuleRecommendationRunOutcomeCallable CancelDataQualityRuleRecommendationRunCallable(const CancelDataQualityRuleRecommendationRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CancelDataQualityRuleRecommendationRun, request);
        }
 
        template<typename CancelDataQualityRuleRecommendationRunRequestT = Model::CancelDataQualityRuleRecommendationRunRequest>
        void CancelDataQualityRuleRecommendationRunAsync(const CancelDataQualityRuleRecommendationRunRequestT& request, const CancelDataQualityRuleRecommendationRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CancelDataQualityRuleRecommendationRun, request, handler, context);
        }
 
        virtual Model::CancelDataQualityRulesetEvaluationRunOutcome CancelDataQualityRulesetEvaluationRun(const Model::CancelDataQualityRulesetEvaluationRunRequest& request) const;
 
        template<typename CancelDataQualityRulesetEvaluationRunRequestT = Model::CancelDataQualityRulesetEvaluationRunRequest>
        Model::CancelDataQualityRulesetEvaluationRunOutcomeCallable CancelDataQualityRulesetEvaluationRunCallable(const CancelDataQualityRulesetEvaluationRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CancelDataQualityRulesetEvaluationRun, request);
        }
 
        template<typename CancelDataQualityRulesetEvaluationRunRequestT = Model::CancelDataQualityRulesetEvaluationRunRequest>
        void CancelDataQualityRulesetEvaluationRunAsync(const CancelDataQualityRulesetEvaluationRunRequestT& request, const CancelDataQualityRulesetEvaluationRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CancelDataQualityRulesetEvaluationRun, request, handler, context);
        }
 
        virtual Model::CancelMLTaskRunOutcome CancelMLTaskRun(const Model::CancelMLTaskRunRequest& request) const;
 
        template<typename CancelMLTaskRunRequestT = Model::CancelMLTaskRunRequest>
        Model::CancelMLTaskRunOutcomeCallable CancelMLTaskRunCallable(const CancelMLTaskRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CancelMLTaskRun, request);
        }
 
        template<typename CancelMLTaskRunRequestT = Model::CancelMLTaskRunRequest>
        void CancelMLTaskRunAsync(const CancelMLTaskRunRequestT& request, const CancelMLTaskRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CancelMLTaskRun, request, handler, context);
        }
 
        virtual Model::CancelStatementOutcome CancelStatement(const Model::CancelStatementRequest& request) const;
 
        template<typename CancelStatementRequestT = Model::CancelStatementRequest>
        Model::CancelStatementOutcomeCallable CancelStatementCallable(const CancelStatementRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CancelStatement, request);
        }
 
        template<typename CancelStatementRequestT = Model::CancelStatementRequest>
        void CancelStatementAsync(const CancelStatementRequestT& request, const CancelStatementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CancelStatement, request, handler, context);
        }
 
        virtual Model::CheckSchemaVersionValidityOutcome CheckSchemaVersionValidity(const Model::CheckSchemaVersionValidityRequest& request) const;
 
        template<typename CheckSchemaVersionValidityRequestT = Model::CheckSchemaVersionValidityRequest>
        Model::CheckSchemaVersionValidityOutcomeCallable CheckSchemaVersionValidityCallable(const CheckSchemaVersionValidityRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CheckSchemaVersionValidity, request);
        }
 
        template<typename CheckSchemaVersionValidityRequestT = Model::CheckSchemaVersionValidityRequest>
        void CheckSchemaVersionValidityAsync(const CheckSchemaVersionValidityRequestT& request, const CheckSchemaVersionValidityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CheckSchemaVersionValidity, request, handler, context);
        }
 
        virtual Model::CreateBlueprintOutcome CreateBlueprint(const Model::CreateBlueprintRequest& request) const;
 
        template<typename CreateBlueprintRequestT = Model::CreateBlueprintRequest>
        Model::CreateBlueprintOutcomeCallable CreateBlueprintCallable(const CreateBlueprintRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateBlueprint, request);
        }
 
        template<typename CreateBlueprintRequestT = Model::CreateBlueprintRequest>
        void CreateBlueprintAsync(const CreateBlueprintRequestT& request, const CreateBlueprintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateBlueprint, request, handler, context);
        }
 
        virtual Model::CreateCatalogOutcome CreateCatalog(const Model::CreateCatalogRequest& request) const;
 
        template<typename CreateCatalogRequestT = Model::CreateCatalogRequest>
        Model::CreateCatalogOutcomeCallable CreateCatalogCallable(const CreateCatalogRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateCatalog, request);
        }
 
        template<typename CreateCatalogRequestT = Model::CreateCatalogRequest>
        void CreateCatalogAsync(const CreateCatalogRequestT& request, const CreateCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateCatalog, request, handler, context);
        }
 
        virtual Model::CreateClassifierOutcome CreateClassifier(const Model::CreateClassifierRequest& request = {}) const;
 
        template<typename CreateClassifierRequestT = Model::CreateClassifierRequest>
        Model::CreateClassifierOutcomeCallable CreateClassifierCallable(const CreateClassifierRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::CreateClassifier, request);
        }
 
        template<typename CreateClassifierRequestT = Model::CreateClassifierRequest>
        void CreateClassifierAsync(const CreateClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateClassifierRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::CreateClassifier, request, handler, context);
        }
 
        virtual Model::CreateColumnStatisticsTaskSettingsOutcome CreateColumnStatisticsTaskSettings(const Model::CreateColumnStatisticsTaskSettingsRequest& request) const;
 
        template<typename CreateColumnStatisticsTaskSettingsRequestT = Model::CreateColumnStatisticsTaskSettingsRequest>
        Model::CreateColumnStatisticsTaskSettingsOutcomeCallable CreateColumnStatisticsTaskSettingsCallable(const CreateColumnStatisticsTaskSettingsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateColumnStatisticsTaskSettings, request);
        }
 
        template<typename CreateColumnStatisticsTaskSettingsRequestT = Model::CreateColumnStatisticsTaskSettingsRequest>
        void CreateColumnStatisticsTaskSettingsAsync(const CreateColumnStatisticsTaskSettingsRequestT& request, const CreateColumnStatisticsTaskSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateColumnStatisticsTaskSettings, request, handler, context);
        }
 
        virtual Model::CreateConnectionOutcome CreateConnection(const Model::CreateConnectionRequest& request) const;
 
        template<typename CreateConnectionRequestT = Model::CreateConnectionRequest>
        Model::CreateConnectionOutcomeCallable CreateConnectionCallable(const CreateConnectionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateConnection, request);
        }
 
        template<typename CreateConnectionRequestT = Model::CreateConnectionRequest>
        void CreateConnectionAsync(const CreateConnectionRequestT& request, const CreateConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateConnection, request, handler, context);
        }
 
        virtual Model::CreateCrawlerOutcome CreateCrawler(const Model::CreateCrawlerRequest& request) const;
 
        template<typename CreateCrawlerRequestT = Model::CreateCrawlerRequest>
        Model::CreateCrawlerOutcomeCallable CreateCrawlerCallable(const CreateCrawlerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateCrawler, request);
        }
 
        template<typename CreateCrawlerRequestT = Model::CreateCrawlerRequest>
        void CreateCrawlerAsync(const CreateCrawlerRequestT& request, const CreateCrawlerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateCrawler, request, handler, context);
        }
 
        virtual Model::CreateCustomEntityTypeOutcome CreateCustomEntityType(const Model::CreateCustomEntityTypeRequest& request) const;
 
        template<typename CreateCustomEntityTypeRequestT = Model::CreateCustomEntityTypeRequest>
        Model::CreateCustomEntityTypeOutcomeCallable CreateCustomEntityTypeCallable(const CreateCustomEntityTypeRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateCustomEntityType, request);
        }
 
        template<typename CreateCustomEntityTypeRequestT = Model::CreateCustomEntityTypeRequest>
        void CreateCustomEntityTypeAsync(const CreateCustomEntityTypeRequestT& request, const CreateCustomEntityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateCustomEntityType, request, handler, context);
        }
 
        virtual Model::CreateDataQualityRulesetOutcome CreateDataQualityRuleset(const Model::CreateDataQualityRulesetRequest& request) const;
 
        template<typename CreateDataQualityRulesetRequestT = Model::CreateDataQualityRulesetRequest>
        Model::CreateDataQualityRulesetOutcomeCallable CreateDataQualityRulesetCallable(const CreateDataQualityRulesetRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateDataQualityRuleset, request);
        }
 
        template<typename CreateDataQualityRulesetRequestT = Model::CreateDataQualityRulesetRequest>
        void CreateDataQualityRulesetAsync(const CreateDataQualityRulesetRequestT& request, const CreateDataQualityRulesetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateDataQualityRuleset, request, handler, context);
        }
 
        virtual Model::CreateDatabaseOutcome CreateDatabase(const Model::CreateDatabaseRequest& request) const;
 
        template<typename CreateDatabaseRequestT = Model::CreateDatabaseRequest>
        Model::CreateDatabaseOutcomeCallable CreateDatabaseCallable(const CreateDatabaseRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateDatabase, request);
        }
 
        template<typename CreateDatabaseRequestT = Model::CreateDatabaseRequest>
        void CreateDatabaseAsync(const CreateDatabaseRequestT& request, const CreateDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateDatabase, request, handler, context);
        }
 
        virtual Model::CreateDevEndpointOutcome CreateDevEndpoint(const Model::CreateDevEndpointRequest& request) const;
 
        template<typename CreateDevEndpointRequestT = Model::CreateDevEndpointRequest>
        Model::CreateDevEndpointOutcomeCallable CreateDevEndpointCallable(const CreateDevEndpointRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateDevEndpoint, request);
        }
 
        template<typename CreateDevEndpointRequestT = Model::CreateDevEndpointRequest>
        void CreateDevEndpointAsync(const CreateDevEndpointRequestT& request, const CreateDevEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateDevEndpoint, request, handler, context);
        }
 
        virtual Model::CreateGlueIdentityCenterConfigurationOutcome CreateGlueIdentityCenterConfiguration(const Model::CreateGlueIdentityCenterConfigurationRequest& request) const;
 
        template<typename CreateGlueIdentityCenterConfigurationRequestT = Model::CreateGlueIdentityCenterConfigurationRequest>
        Model::CreateGlueIdentityCenterConfigurationOutcomeCallable CreateGlueIdentityCenterConfigurationCallable(const CreateGlueIdentityCenterConfigurationRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateGlueIdentityCenterConfiguration, request);
        }
 
        template<typename CreateGlueIdentityCenterConfigurationRequestT = Model::CreateGlueIdentityCenterConfigurationRequest>
        void CreateGlueIdentityCenterConfigurationAsync(const CreateGlueIdentityCenterConfigurationRequestT& request, const CreateGlueIdentityCenterConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateGlueIdentityCenterConfiguration, request, handler, context);
        }
 
        virtual Model::CreateIntegrationOutcome CreateIntegration(const Model::CreateIntegrationRequest& request) const;
 
        template<typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
        Model::CreateIntegrationOutcomeCallable CreateIntegrationCallable(const CreateIntegrationRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateIntegration, request);
        }
 
        template<typename CreateIntegrationRequestT = Model::CreateIntegrationRequest>
        void CreateIntegrationAsync(const CreateIntegrationRequestT& request, const CreateIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateIntegration, request, handler, context);
        }
 
        virtual Model::CreateIntegrationResourcePropertyOutcome CreateIntegrationResourceProperty(const Model::CreateIntegrationResourcePropertyRequest& request) const;
 
        template<typename CreateIntegrationResourcePropertyRequestT = Model::CreateIntegrationResourcePropertyRequest>
        Model::CreateIntegrationResourcePropertyOutcomeCallable CreateIntegrationResourcePropertyCallable(const CreateIntegrationResourcePropertyRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateIntegrationResourceProperty, request);
        }
 
        template<typename CreateIntegrationResourcePropertyRequestT = Model::CreateIntegrationResourcePropertyRequest>
        void CreateIntegrationResourcePropertyAsync(const CreateIntegrationResourcePropertyRequestT& request, const CreateIntegrationResourcePropertyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateIntegrationResourceProperty, request, handler, context);
        }
 
        virtual Model::CreateIntegrationTablePropertiesOutcome CreateIntegrationTableProperties(const Model::CreateIntegrationTablePropertiesRequest& request) const;
 
        template<typename CreateIntegrationTablePropertiesRequestT = Model::CreateIntegrationTablePropertiesRequest>
        Model::CreateIntegrationTablePropertiesOutcomeCallable CreateIntegrationTablePropertiesCallable(const CreateIntegrationTablePropertiesRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateIntegrationTableProperties, request);
        }
 
        template<typename CreateIntegrationTablePropertiesRequestT = Model::CreateIntegrationTablePropertiesRequest>
        void CreateIntegrationTablePropertiesAsync(const CreateIntegrationTablePropertiesRequestT& request, const CreateIntegrationTablePropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateIntegrationTableProperties, request, handler, context);
        }
 
        virtual Model::CreateJobOutcome CreateJob(const Model::CreateJobRequest& request) const;
 
        template<typename CreateJobRequestT = Model::CreateJobRequest>
        Model::CreateJobOutcomeCallable CreateJobCallable(const CreateJobRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateJob, request);
        }
 
        template<typename CreateJobRequestT = Model::CreateJobRequest>
        void CreateJobAsync(const CreateJobRequestT& request, const CreateJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateJob, request, handler, context);
        }
 
        virtual Model::CreateMLTransformOutcome CreateMLTransform(const Model::CreateMLTransformRequest& request) const;
 
        template<typename CreateMLTransformRequestT = Model::CreateMLTransformRequest>
        Model::CreateMLTransformOutcomeCallable CreateMLTransformCallable(const CreateMLTransformRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateMLTransform, request);
        }
 
        template<typename CreateMLTransformRequestT = Model::CreateMLTransformRequest>
        void CreateMLTransformAsync(const CreateMLTransformRequestT& request, const CreateMLTransformResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateMLTransform, request, handler, context);
        }
 
        virtual Model::CreatePartitionOutcome CreatePartition(const Model::CreatePartitionRequest& request) const;
 
        template<typename CreatePartitionRequestT = Model::CreatePartitionRequest>
        Model::CreatePartitionOutcomeCallable CreatePartitionCallable(const CreatePartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreatePartition, request);
        }
 
        template<typename CreatePartitionRequestT = Model::CreatePartitionRequest>
        void CreatePartitionAsync(const CreatePartitionRequestT& request, const CreatePartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreatePartition, request, handler, context);
        }
 
        virtual Model::CreatePartitionIndexOutcome CreatePartitionIndex(const Model::CreatePartitionIndexRequest& request) const;
 
        template<typename CreatePartitionIndexRequestT = Model::CreatePartitionIndexRequest>
        Model::CreatePartitionIndexOutcomeCallable CreatePartitionIndexCallable(const CreatePartitionIndexRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreatePartitionIndex, request);
        }
 
        template<typename CreatePartitionIndexRequestT = Model::CreatePartitionIndexRequest>
        void CreatePartitionIndexAsync(const CreatePartitionIndexRequestT& request, const CreatePartitionIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreatePartitionIndex, request, handler, context);
        }
 
        virtual Model::CreateRegistryOutcome CreateRegistry(const Model::CreateRegistryRequest& request) const;
 
        template<typename CreateRegistryRequestT = Model::CreateRegistryRequest>
        Model::CreateRegistryOutcomeCallable CreateRegistryCallable(const CreateRegistryRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateRegistry, request);
        }
 
        template<typename CreateRegistryRequestT = Model::CreateRegistryRequest>
        void CreateRegistryAsync(const CreateRegistryRequestT& request, const CreateRegistryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateRegistry, 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(&GlueClient::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(&GlueClient::CreateSchema, request, handler, context);
        }
 
        virtual Model::CreateScriptOutcome CreateScript(const Model::CreateScriptRequest& request = {}) const;
 
        template<typename CreateScriptRequestT = Model::CreateScriptRequest>
        Model::CreateScriptOutcomeCallable CreateScriptCallable(const CreateScriptRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::CreateScript, request);
        }
 
        template<typename CreateScriptRequestT = Model::CreateScriptRequest>
        void CreateScriptAsync(const CreateScriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateScriptRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::CreateScript, request, handler, context);
        }
 
        virtual Model::CreateSecurityConfigurationOutcome CreateSecurityConfiguration(const Model::CreateSecurityConfigurationRequest& request) const;
 
        template<typename CreateSecurityConfigurationRequestT = Model::CreateSecurityConfigurationRequest>
        Model::CreateSecurityConfigurationOutcomeCallable CreateSecurityConfigurationCallable(const CreateSecurityConfigurationRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateSecurityConfiguration, request);
        }
 
        template<typename CreateSecurityConfigurationRequestT = Model::CreateSecurityConfigurationRequest>
        void CreateSecurityConfigurationAsync(const CreateSecurityConfigurationRequestT& request, const CreateSecurityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateSecurityConfiguration, request, handler, context);
        }
 
        virtual Model::CreateSessionOutcome CreateSession(const Model::CreateSessionRequest& request) const;
 
        template<typename CreateSessionRequestT = Model::CreateSessionRequest>
        Model::CreateSessionOutcomeCallable CreateSessionCallable(const CreateSessionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateSession, request);
        }
 
        template<typename CreateSessionRequestT = Model::CreateSessionRequest>
        void CreateSessionAsync(const CreateSessionRequestT& request, const CreateSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateSession, request, handler, context);
        }
 
        virtual Model::CreateTableOutcome CreateTable(const Model::CreateTableRequest& request) const;
 
        template<typename CreateTableRequestT = Model::CreateTableRequest>
        Model::CreateTableOutcomeCallable CreateTableCallable(const CreateTableRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateTable, request);
        }
 
        template<typename CreateTableRequestT = Model::CreateTableRequest>
        void CreateTableAsync(const CreateTableRequestT& request, const CreateTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateTable, request, handler, context);
        }
 
        virtual Model::CreateTableOptimizerOutcome CreateTableOptimizer(const Model::CreateTableOptimizerRequest& request) const;
 
        template<typename CreateTableOptimizerRequestT = Model::CreateTableOptimizerRequest>
        Model::CreateTableOptimizerOutcomeCallable CreateTableOptimizerCallable(const CreateTableOptimizerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateTableOptimizer, request);
        }
 
        template<typename CreateTableOptimizerRequestT = Model::CreateTableOptimizerRequest>
        void CreateTableOptimizerAsync(const CreateTableOptimizerRequestT& request, const CreateTableOptimizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateTableOptimizer, request, handler, context);
        }
 
        virtual Model::CreateTriggerOutcome CreateTrigger(const Model::CreateTriggerRequest& request) const;
 
        template<typename CreateTriggerRequestT = Model::CreateTriggerRequest>
        Model::CreateTriggerOutcomeCallable CreateTriggerCallable(const CreateTriggerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateTrigger, request);
        }
 
        template<typename CreateTriggerRequestT = Model::CreateTriggerRequest>
        void CreateTriggerAsync(const CreateTriggerRequestT& request, const CreateTriggerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateTrigger, request, handler, context);
        }
 
        virtual Model::CreateUsageProfileOutcome CreateUsageProfile(const Model::CreateUsageProfileRequest& request) const;
 
        template<typename CreateUsageProfileRequestT = Model::CreateUsageProfileRequest>
        Model::CreateUsageProfileOutcomeCallable CreateUsageProfileCallable(const CreateUsageProfileRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateUsageProfile, request);
        }
 
        template<typename CreateUsageProfileRequestT = Model::CreateUsageProfileRequest>
        void CreateUsageProfileAsync(const CreateUsageProfileRequestT& request, const CreateUsageProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateUsageProfile, request, handler, context);
        }
 
        virtual Model::CreateUserDefinedFunctionOutcome CreateUserDefinedFunction(const Model::CreateUserDefinedFunctionRequest& request) const;
 
        template<typename CreateUserDefinedFunctionRequestT = Model::CreateUserDefinedFunctionRequest>
        Model::CreateUserDefinedFunctionOutcomeCallable CreateUserDefinedFunctionCallable(const CreateUserDefinedFunctionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateUserDefinedFunction, request);
        }
 
        template<typename CreateUserDefinedFunctionRequestT = Model::CreateUserDefinedFunctionRequest>
        void CreateUserDefinedFunctionAsync(const CreateUserDefinedFunctionRequestT& request, const CreateUserDefinedFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateUserDefinedFunction, request, handler, context);
        }
 
        virtual Model::CreateWorkflowOutcome CreateWorkflow(const Model::CreateWorkflowRequest& request) const;
 
        template<typename CreateWorkflowRequestT = Model::CreateWorkflowRequest>
        Model::CreateWorkflowOutcomeCallable CreateWorkflowCallable(const CreateWorkflowRequestT& request) const
        {
            return SubmitCallable(&GlueClient::CreateWorkflow, request);
        }
 
        template<typename CreateWorkflowRequestT = Model::CreateWorkflowRequest>
        void CreateWorkflowAsync(const CreateWorkflowRequestT& request, const CreateWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::CreateWorkflow, request, handler, context);
        }
 
        virtual Model::DeleteBlueprintOutcome DeleteBlueprint(const Model::DeleteBlueprintRequest& request) const;
 
        template<typename DeleteBlueprintRequestT = Model::DeleteBlueprintRequest>
        Model::DeleteBlueprintOutcomeCallable DeleteBlueprintCallable(const DeleteBlueprintRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteBlueprint, request);
        }
 
        template<typename DeleteBlueprintRequestT = Model::DeleteBlueprintRequest>
        void DeleteBlueprintAsync(const DeleteBlueprintRequestT& request, const DeleteBlueprintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteBlueprint, request, handler, context);
        }
 
        virtual Model::DeleteCatalogOutcome DeleteCatalog(const Model::DeleteCatalogRequest& request) const;
 
        template<typename DeleteCatalogRequestT = Model::DeleteCatalogRequest>
        Model::DeleteCatalogOutcomeCallable DeleteCatalogCallable(const DeleteCatalogRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteCatalog, request);
        }
 
        template<typename DeleteCatalogRequestT = Model::DeleteCatalogRequest>
        void DeleteCatalogAsync(const DeleteCatalogRequestT& request, const DeleteCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteCatalog, request, handler, context);
        }
 
        virtual Model::DeleteClassifierOutcome DeleteClassifier(const Model::DeleteClassifierRequest& request) const;
 
        template<typename DeleteClassifierRequestT = Model::DeleteClassifierRequest>
        Model::DeleteClassifierOutcomeCallable DeleteClassifierCallable(const DeleteClassifierRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteClassifier, request);
        }
 
        template<typename DeleteClassifierRequestT = Model::DeleteClassifierRequest>
        void DeleteClassifierAsync(const DeleteClassifierRequestT& request, const DeleteClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteClassifier, request, handler, context);
        }
 
        virtual Model::DeleteColumnStatisticsForPartitionOutcome DeleteColumnStatisticsForPartition(const Model::DeleteColumnStatisticsForPartitionRequest& request) const;
 
        template<typename DeleteColumnStatisticsForPartitionRequestT = Model::DeleteColumnStatisticsForPartitionRequest>
        Model::DeleteColumnStatisticsForPartitionOutcomeCallable DeleteColumnStatisticsForPartitionCallable(const DeleteColumnStatisticsForPartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteColumnStatisticsForPartition, request);
        }
 
        template<typename DeleteColumnStatisticsForPartitionRequestT = Model::DeleteColumnStatisticsForPartitionRequest>
        void DeleteColumnStatisticsForPartitionAsync(const DeleteColumnStatisticsForPartitionRequestT& request, const DeleteColumnStatisticsForPartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteColumnStatisticsForPartition, request, handler, context);
        }
 
        virtual Model::DeleteColumnStatisticsForTableOutcome DeleteColumnStatisticsForTable(const Model::DeleteColumnStatisticsForTableRequest& request) const;
 
        template<typename DeleteColumnStatisticsForTableRequestT = Model::DeleteColumnStatisticsForTableRequest>
        Model::DeleteColumnStatisticsForTableOutcomeCallable DeleteColumnStatisticsForTableCallable(const DeleteColumnStatisticsForTableRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteColumnStatisticsForTable, request);
        }
 
        template<typename DeleteColumnStatisticsForTableRequestT = Model::DeleteColumnStatisticsForTableRequest>
        void DeleteColumnStatisticsForTableAsync(const DeleteColumnStatisticsForTableRequestT& request, const DeleteColumnStatisticsForTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteColumnStatisticsForTable, request, handler, context);
        }
 
        virtual Model::DeleteColumnStatisticsTaskSettingsOutcome DeleteColumnStatisticsTaskSettings(const Model::DeleteColumnStatisticsTaskSettingsRequest& request) const;
 
        template<typename DeleteColumnStatisticsTaskSettingsRequestT = Model::DeleteColumnStatisticsTaskSettingsRequest>
        Model::DeleteColumnStatisticsTaskSettingsOutcomeCallable DeleteColumnStatisticsTaskSettingsCallable(const DeleteColumnStatisticsTaskSettingsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteColumnStatisticsTaskSettings, request);
        }
 
        template<typename DeleteColumnStatisticsTaskSettingsRequestT = Model::DeleteColumnStatisticsTaskSettingsRequest>
        void DeleteColumnStatisticsTaskSettingsAsync(const DeleteColumnStatisticsTaskSettingsRequestT& request, const DeleteColumnStatisticsTaskSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteColumnStatisticsTaskSettings, request, handler, context);
        }
 
        virtual Model::DeleteConnectionOutcome DeleteConnection(const Model::DeleteConnectionRequest& request) const;
 
        template<typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
        Model::DeleteConnectionOutcomeCallable DeleteConnectionCallable(const DeleteConnectionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteConnection, request);
        }
 
        template<typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
        void DeleteConnectionAsync(const DeleteConnectionRequestT& request, const DeleteConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteConnection, request, handler, context);
        }
 
        virtual Model::DeleteCrawlerOutcome DeleteCrawler(const Model::DeleteCrawlerRequest& request) const;
 
        template<typename DeleteCrawlerRequestT = Model::DeleteCrawlerRequest>
        Model::DeleteCrawlerOutcomeCallable DeleteCrawlerCallable(const DeleteCrawlerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteCrawler, request);
        }
 
        template<typename DeleteCrawlerRequestT = Model::DeleteCrawlerRequest>
        void DeleteCrawlerAsync(const DeleteCrawlerRequestT& request, const DeleteCrawlerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteCrawler, request, handler, context);
        }
 
        virtual Model::DeleteCustomEntityTypeOutcome DeleteCustomEntityType(const Model::DeleteCustomEntityTypeRequest& request) const;
 
        template<typename DeleteCustomEntityTypeRequestT = Model::DeleteCustomEntityTypeRequest>
        Model::DeleteCustomEntityTypeOutcomeCallable DeleteCustomEntityTypeCallable(const DeleteCustomEntityTypeRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteCustomEntityType, request);
        }
 
        template<typename DeleteCustomEntityTypeRequestT = Model::DeleteCustomEntityTypeRequest>
        void DeleteCustomEntityTypeAsync(const DeleteCustomEntityTypeRequestT& request, const DeleteCustomEntityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteCustomEntityType, request, handler, context);
        }
 
        virtual Model::DeleteDataQualityRulesetOutcome DeleteDataQualityRuleset(const Model::DeleteDataQualityRulesetRequest& request) const;
 
        template<typename DeleteDataQualityRulesetRequestT = Model::DeleteDataQualityRulesetRequest>
        Model::DeleteDataQualityRulesetOutcomeCallable DeleteDataQualityRulesetCallable(const DeleteDataQualityRulesetRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteDataQualityRuleset, request);
        }
 
        template<typename DeleteDataQualityRulesetRequestT = Model::DeleteDataQualityRulesetRequest>
        void DeleteDataQualityRulesetAsync(const DeleteDataQualityRulesetRequestT& request, const DeleteDataQualityRulesetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteDataQualityRuleset, request, handler, context);
        }
 
        virtual Model::DeleteDatabaseOutcome DeleteDatabase(const Model::DeleteDatabaseRequest& request) const;
 
        template<typename DeleteDatabaseRequestT = Model::DeleteDatabaseRequest>
        Model::DeleteDatabaseOutcomeCallable DeleteDatabaseCallable(const DeleteDatabaseRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteDatabase, request);
        }
 
        template<typename DeleteDatabaseRequestT = Model::DeleteDatabaseRequest>
        void DeleteDatabaseAsync(const DeleteDatabaseRequestT& request, const DeleteDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteDatabase, request, handler, context);
        }
 
        virtual Model::DeleteDevEndpointOutcome DeleteDevEndpoint(const Model::DeleteDevEndpointRequest& request) const;
 
        template<typename DeleteDevEndpointRequestT = Model::DeleteDevEndpointRequest>
        Model::DeleteDevEndpointOutcomeCallable DeleteDevEndpointCallable(const DeleteDevEndpointRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteDevEndpoint, request);
        }
 
        template<typename DeleteDevEndpointRequestT = Model::DeleteDevEndpointRequest>
        void DeleteDevEndpointAsync(const DeleteDevEndpointRequestT& request, const DeleteDevEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteDevEndpoint, request, handler, context);
        }
 
        virtual Model::DeleteGlueIdentityCenterConfigurationOutcome DeleteGlueIdentityCenterConfiguration(const Model::DeleteGlueIdentityCenterConfigurationRequest& request = {}) const;
 
        template<typename DeleteGlueIdentityCenterConfigurationRequestT = Model::DeleteGlueIdentityCenterConfigurationRequest>
        Model::DeleteGlueIdentityCenterConfigurationOutcomeCallable DeleteGlueIdentityCenterConfigurationCallable(const DeleteGlueIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::DeleteGlueIdentityCenterConfiguration, request);
        }
 
        template<typename DeleteGlueIdentityCenterConfigurationRequestT = Model::DeleteGlueIdentityCenterConfigurationRequest>
        void DeleteGlueIdentityCenterConfigurationAsync(const DeleteGlueIdentityCenterConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteGlueIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::DeleteGlueIdentityCenterConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteIntegrationOutcome DeleteIntegration(const Model::DeleteIntegrationRequest& request) const;
 
        template<typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
        Model::DeleteIntegrationOutcomeCallable DeleteIntegrationCallable(const DeleteIntegrationRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteIntegration, request);
        }
 
        template<typename DeleteIntegrationRequestT = Model::DeleteIntegrationRequest>
        void DeleteIntegrationAsync(const DeleteIntegrationRequestT& request, const DeleteIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteIntegration, request, handler, context);
        }
 
        virtual Model::DeleteIntegrationTablePropertiesOutcome DeleteIntegrationTableProperties(const Model::DeleteIntegrationTablePropertiesRequest& request) const;
 
        template<typename DeleteIntegrationTablePropertiesRequestT = Model::DeleteIntegrationTablePropertiesRequest>
        Model::DeleteIntegrationTablePropertiesOutcomeCallable DeleteIntegrationTablePropertiesCallable(const DeleteIntegrationTablePropertiesRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteIntegrationTableProperties, request);
        }
 
        template<typename DeleteIntegrationTablePropertiesRequestT = Model::DeleteIntegrationTablePropertiesRequest>
        void DeleteIntegrationTablePropertiesAsync(const DeleteIntegrationTablePropertiesRequestT& request, const DeleteIntegrationTablePropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteIntegrationTableProperties, 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(&GlueClient::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(&GlueClient::DeleteJob, request, handler, context);
        }
 
        virtual Model::DeleteMLTransformOutcome DeleteMLTransform(const Model::DeleteMLTransformRequest& request) const;
 
        template<typename DeleteMLTransformRequestT = Model::DeleteMLTransformRequest>
        Model::DeleteMLTransformOutcomeCallable DeleteMLTransformCallable(const DeleteMLTransformRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteMLTransform, request);
        }
 
        template<typename DeleteMLTransformRequestT = Model::DeleteMLTransformRequest>
        void DeleteMLTransformAsync(const DeleteMLTransformRequestT& request, const DeleteMLTransformResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteMLTransform, request, handler, context);
        }
 
        virtual Model::DeletePartitionOutcome DeletePartition(const Model::DeletePartitionRequest& request) const;
 
        template<typename DeletePartitionRequestT = Model::DeletePartitionRequest>
        Model::DeletePartitionOutcomeCallable DeletePartitionCallable(const DeletePartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeletePartition, request);
        }
 
        template<typename DeletePartitionRequestT = Model::DeletePartitionRequest>
        void DeletePartitionAsync(const DeletePartitionRequestT& request, const DeletePartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeletePartition, request, handler, context);
        }
 
        virtual Model::DeletePartitionIndexOutcome DeletePartitionIndex(const Model::DeletePartitionIndexRequest& request) const;
 
        template<typename DeletePartitionIndexRequestT = Model::DeletePartitionIndexRequest>
        Model::DeletePartitionIndexOutcomeCallable DeletePartitionIndexCallable(const DeletePartitionIndexRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeletePartitionIndex, request);
        }
 
        template<typename DeletePartitionIndexRequestT = Model::DeletePartitionIndexRequest>
        void DeletePartitionIndexAsync(const DeletePartitionIndexRequestT& request, const DeletePartitionIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeletePartitionIndex, request, handler, context);
        }
 
        virtual Model::DeleteRegistryOutcome DeleteRegistry(const Model::DeleteRegistryRequest& request) const;
 
        template<typename DeleteRegistryRequestT = Model::DeleteRegistryRequest>
        Model::DeleteRegistryOutcomeCallable DeleteRegistryCallable(const DeleteRegistryRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteRegistry, request);
        }
 
        template<typename DeleteRegistryRequestT = Model::DeleteRegistryRequest>
        void DeleteRegistryAsync(const DeleteRegistryRequestT& request, const DeleteRegistryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteRegistry, request, handler, context);
        }
 
        virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request = {}) const;
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::DeleteResourcePolicy, request);
        }
 
        template<typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
        void DeleteResourcePolicyAsync(const DeleteResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteResourcePolicyRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::DeleteResourcePolicy, 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(&GlueClient::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(&GlueClient::DeleteSchema, request, handler, context);
        }
 
        virtual Model::DeleteSchemaVersionsOutcome DeleteSchemaVersions(const Model::DeleteSchemaVersionsRequest& request) const;
 
        template<typename DeleteSchemaVersionsRequestT = Model::DeleteSchemaVersionsRequest>
        Model::DeleteSchemaVersionsOutcomeCallable DeleteSchemaVersionsCallable(const DeleteSchemaVersionsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteSchemaVersions, request);
        }
 
        template<typename DeleteSchemaVersionsRequestT = Model::DeleteSchemaVersionsRequest>
        void DeleteSchemaVersionsAsync(const DeleteSchemaVersionsRequestT& request, const DeleteSchemaVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteSchemaVersions, request, handler, context);
        }
 
        virtual Model::DeleteSecurityConfigurationOutcome DeleteSecurityConfiguration(const Model::DeleteSecurityConfigurationRequest& request) const;
 
        template<typename DeleteSecurityConfigurationRequestT = Model::DeleteSecurityConfigurationRequest>
        Model::DeleteSecurityConfigurationOutcomeCallable DeleteSecurityConfigurationCallable(const DeleteSecurityConfigurationRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteSecurityConfiguration, request);
        }
 
        template<typename DeleteSecurityConfigurationRequestT = Model::DeleteSecurityConfigurationRequest>
        void DeleteSecurityConfigurationAsync(const DeleteSecurityConfigurationRequestT& request, const DeleteSecurityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteSecurityConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteSessionOutcome DeleteSession(const Model::DeleteSessionRequest& request) const;
 
        template<typename DeleteSessionRequestT = Model::DeleteSessionRequest>
        Model::DeleteSessionOutcomeCallable DeleteSessionCallable(const DeleteSessionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteSession, request);
        }
 
        template<typename DeleteSessionRequestT = Model::DeleteSessionRequest>
        void DeleteSessionAsync(const DeleteSessionRequestT& request, const DeleteSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteSession, request, handler, context);
        }
 
        virtual Model::DeleteTableOutcome DeleteTable(const Model::DeleteTableRequest& request) const;
 
        template<typename DeleteTableRequestT = Model::DeleteTableRequest>
        Model::DeleteTableOutcomeCallable DeleteTableCallable(const DeleteTableRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteTable, request);
        }
 
        template<typename DeleteTableRequestT = Model::DeleteTableRequest>
        void DeleteTableAsync(const DeleteTableRequestT& request, const DeleteTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteTable, request, handler, context);
        }
 
        virtual Model::DeleteTableOptimizerOutcome DeleteTableOptimizer(const Model::DeleteTableOptimizerRequest& request) const;
 
        template<typename DeleteTableOptimizerRequestT = Model::DeleteTableOptimizerRequest>
        Model::DeleteTableOptimizerOutcomeCallable DeleteTableOptimizerCallable(const DeleteTableOptimizerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteTableOptimizer, request);
        }
 
        template<typename DeleteTableOptimizerRequestT = Model::DeleteTableOptimizerRequest>
        void DeleteTableOptimizerAsync(const DeleteTableOptimizerRequestT& request, const DeleteTableOptimizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteTableOptimizer, request, handler, context);
        }
 
        virtual Model::DeleteTableVersionOutcome DeleteTableVersion(const Model::DeleteTableVersionRequest& request) const;
 
        template<typename DeleteTableVersionRequestT = Model::DeleteTableVersionRequest>
        Model::DeleteTableVersionOutcomeCallable DeleteTableVersionCallable(const DeleteTableVersionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteTableVersion, request);
        }
 
        template<typename DeleteTableVersionRequestT = Model::DeleteTableVersionRequest>
        void DeleteTableVersionAsync(const DeleteTableVersionRequestT& request, const DeleteTableVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteTableVersion, request, handler, context);
        }
 
        virtual Model::DeleteTriggerOutcome DeleteTrigger(const Model::DeleteTriggerRequest& request) const;
 
        template<typename DeleteTriggerRequestT = Model::DeleteTriggerRequest>
        Model::DeleteTriggerOutcomeCallable DeleteTriggerCallable(const DeleteTriggerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteTrigger, request);
        }
 
        template<typename DeleteTriggerRequestT = Model::DeleteTriggerRequest>
        void DeleteTriggerAsync(const DeleteTriggerRequestT& request, const DeleteTriggerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteTrigger, request, handler, context);
        }
 
        virtual Model::DeleteUsageProfileOutcome DeleteUsageProfile(const Model::DeleteUsageProfileRequest& request) const;
 
        template<typename DeleteUsageProfileRequestT = Model::DeleteUsageProfileRequest>
        Model::DeleteUsageProfileOutcomeCallable DeleteUsageProfileCallable(const DeleteUsageProfileRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteUsageProfile, request);
        }
 
        template<typename DeleteUsageProfileRequestT = Model::DeleteUsageProfileRequest>
        void DeleteUsageProfileAsync(const DeleteUsageProfileRequestT& request, const DeleteUsageProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteUsageProfile, request, handler, context);
        }
 
        virtual Model::DeleteUserDefinedFunctionOutcome DeleteUserDefinedFunction(const Model::DeleteUserDefinedFunctionRequest& request) const;
 
        template<typename DeleteUserDefinedFunctionRequestT = Model::DeleteUserDefinedFunctionRequest>
        Model::DeleteUserDefinedFunctionOutcomeCallable DeleteUserDefinedFunctionCallable(const DeleteUserDefinedFunctionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteUserDefinedFunction, request);
        }
 
        template<typename DeleteUserDefinedFunctionRequestT = Model::DeleteUserDefinedFunctionRequest>
        void DeleteUserDefinedFunctionAsync(const DeleteUserDefinedFunctionRequestT& request, const DeleteUserDefinedFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteUserDefinedFunction, request, handler, context);
        }
 
        virtual Model::DeleteWorkflowOutcome DeleteWorkflow(const Model::DeleteWorkflowRequest& request) const;
 
        template<typename DeleteWorkflowRequestT = Model::DeleteWorkflowRequest>
        Model::DeleteWorkflowOutcomeCallable DeleteWorkflowCallable(const DeleteWorkflowRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DeleteWorkflow, request);
        }
 
        template<typename DeleteWorkflowRequestT = Model::DeleteWorkflowRequest>
        void DeleteWorkflowAsync(const DeleteWorkflowRequestT& request, const DeleteWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DeleteWorkflow, request, handler, context);
        }
 
        virtual Model::DescribeConnectionTypeOutcome DescribeConnectionType(const Model::DescribeConnectionTypeRequest& request) const;
 
        template<typename DescribeConnectionTypeRequestT = Model::DescribeConnectionTypeRequest>
        Model::DescribeConnectionTypeOutcomeCallable DescribeConnectionTypeCallable(const DescribeConnectionTypeRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DescribeConnectionType, request);
        }
 
        template<typename DescribeConnectionTypeRequestT = Model::DescribeConnectionTypeRequest>
        void DescribeConnectionTypeAsync(const DescribeConnectionTypeRequestT& request, const DescribeConnectionTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DescribeConnectionType, request, handler, context);
        }
 
        virtual Model::DescribeEntityOutcome DescribeEntity(const Model::DescribeEntityRequest& request) const;
 
        template<typename DescribeEntityRequestT = Model::DescribeEntityRequest>
        Model::DescribeEntityOutcomeCallable DescribeEntityCallable(const DescribeEntityRequestT& request) const
        {
            return SubmitCallable(&GlueClient::DescribeEntity, request);
        }
 
        template<typename DescribeEntityRequestT = Model::DescribeEntityRequest>
        void DescribeEntityAsync(const DescribeEntityRequestT& request, const DescribeEntityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::DescribeEntity, request, handler, context);
        }
 
        virtual Model::DescribeInboundIntegrationsOutcome DescribeInboundIntegrations(const Model::DescribeInboundIntegrationsRequest& request = {}) const;
 
        template<typename DescribeInboundIntegrationsRequestT = Model::DescribeInboundIntegrationsRequest>
        Model::DescribeInboundIntegrationsOutcomeCallable DescribeInboundIntegrationsCallable(const DescribeInboundIntegrationsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::DescribeInboundIntegrations, request);
        }
 
        template<typename DescribeInboundIntegrationsRequestT = Model::DescribeInboundIntegrationsRequest>
        void DescribeInboundIntegrationsAsync(const DescribeInboundIntegrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeInboundIntegrationsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::DescribeInboundIntegrations, request, handler, context);
        }
 
        virtual Model::DescribeIntegrationsOutcome DescribeIntegrations(const Model::DescribeIntegrationsRequest& request = {}) const;
 
        template<typename DescribeIntegrationsRequestT = Model::DescribeIntegrationsRequest>
        Model::DescribeIntegrationsOutcomeCallable DescribeIntegrationsCallable(const DescribeIntegrationsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::DescribeIntegrations, request);
        }
 
        template<typename DescribeIntegrationsRequestT = Model::DescribeIntegrationsRequest>
        void DescribeIntegrationsAsync(const DescribeIntegrationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeIntegrationsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::DescribeIntegrations, request, handler, context);
        }
 
        virtual Model::GetBlueprintOutcome GetBlueprint(const Model::GetBlueprintRequest& request) const;
 
        template<typename GetBlueprintRequestT = Model::GetBlueprintRequest>
        Model::GetBlueprintOutcomeCallable GetBlueprintCallable(const GetBlueprintRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetBlueprint, request);
        }
 
        template<typename GetBlueprintRequestT = Model::GetBlueprintRequest>
        void GetBlueprintAsync(const GetBlueprintRequestT& request, const GetBlueprintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetBlueprint, request, handler, context);
        }
 
        virtual Model::GetBlueprintRunOutcome GetBlueprintRun(const Model::GetBlueprintRunRequest& request) const;
 
        template<typename GetBlueprintRunRequestT = Model::GetBlueprintRunRequest>
        Model::GetBlueprintRunOutcomeCallable GetBlueprintRunCallable(const GetBlueprintRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetBlueprintRun, request);
        }
 
        template<typename GetBlueprintRunRequestT = Model::GetBlueprintRunRequest>
        void GetBlueprintRunAsync(const GetBlueprintRunRequestT& request, const GetBlueprintRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetBlueprintRun, request, handler, context);
        }
 
        virtual Model::GetBlueprintRunsOutcome GetBlueprintRuns(const Model::GetBlueprintRunsRequest& request) const;
 
        template<typename GetBlueprintRunsRequestT = Model::GetBlueprintRunsRequest>
        Model::GetBlueprintRunsOutcomeCallable GetBlueprintRunsCallable(const GetBlueprintRunsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetBlueprintRuns, request);
        }
 
        template<typename GetBlueprintRunsRequestT = Model::GetBlueprintRunsRequest>
        void GetBlueprintRunsAsync(const GetBlueprintRunsRequestT& request, const GetBlueprintRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetBlueprintRuns, request, handler, context);
        }
 
        virtual Model::GetCatalogOutcome GetCatalog(const Model::GetCatalogRequest& request) const;
 
        template<typename GetCatalogRequestT = Model::GetCatalogRequest>
        Model::GetCatalogOutcomeCallable GetCatalogCallable(const GetCatalogRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetCatalog, request);
        }
 
        template<typename GetCatalogRequestT = Model::GetCatalogRequest>
        void GetCatalogAsync(const GetCatalogRequestT& request, const GetCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetCatalog, request, handler, context);
        }
 
        virtual Model::GetCatalogImportStatusOutcome GetCatalogImportStatus(const Model::GetCatalogImportStatusRequest& request = {}) const;
 
        template<typename GetCatalogImportStatusRequestT = Model::GetCatalogImportStatusRequest>
        Model::GetCatalogImportStatusOutcomeCallable GetCatalogImportStatusCallable(const GetCatalogImportStatusRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetCatalogImportStatus, request);
        }
 
        template<typename GetCatalogImportStatusRequestT = Model::GetCatalogImportStatusRequest>
        void GetCatalogImportStatusAsync(const GetCatalogImportStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetCatalogImportStatusRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetCatalogImportStatus, request, handler, context);
        }
 
        virtual Model::GetCatalogsOutcome GetCatalogs(const Model::GetCatalogsRequest& request = {}) const;
 
        template<typename GetCatalogsRequestT = Model::GetCatalogsRequest>
        Model::GetCatalogsOutcomeCallable GetCatalogsCallable(const GetCatalogsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetCatalogs, request);
        }
 
        template<typename GetCatalogsRequestT = Model::GetCatalogsRequest>
        void GetCatalogsAsync(const GetCatalogsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetCatalogsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetCatalogs, request, handler, context);
        }
 
        virtual Model::GetClassifierOutcome GetClassifier(const Model::GetClassifierRequest& request) const;
 
        template<typename GetClassifierRequestT = Model::GetClassifierRequest>
        Model::GetClassifierOutcomeCallable GetClassifierCallable(const GetClassifierRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetClassifier, request);
        }
 
        template<typename GetClassifierRequestT = Model::GetClassifierRequest>
        void GetClassifierAsync(const GetClassifierRequestT& request, const GetClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetClassifier, request, handler, context);
        }
 
        virtual Model::GetClassifiersOutcome GetClassifiers(const Model::GetClassifiersRequest& request = {}) const;
 
        template<typename GetClassifiersRequestT = Model::GetClassifiersRequest>
        Model::GetClassifiersOutcomeCallable GetClassifiersCallable(const GetClassifiersRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetClassifiers, request);
        }
 
        template<typename GetClassifiersRequestT = Model::GetClassifiersRequest>
        void GetClassifiersAsync(const GetClassifiersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetClassifiersRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetClassifiers, request, handler, context);
        }
 
        virtual Model::GetColumnStatisticsForPartitionOutcome GetColumnStatisticsForPartition(const Model::GetColumnStatisticsForPartitionRequest& request) const;
 
        template<typename GetColumnStatisticsForPartitionRequestT = Model::GetColumnStatisticsForPartitionRequest>
        Model::GetColumnStatisticsForPartitionOutcomeCallable GetColumnStatisticsForPartitionCallable(const GetColumnStatisticsForPartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetColumnStatisticsForPartition, request);
        }
 
        template<typename GetColumnStatisticsForPartitionRequestT = Model::GetColumnStatisticsForPartitionRequest>
        void GetColumnStatisticsForPartitionAsync(const GetColumnStatisticsForPartitionRequestT& request, const GetColumnStatisticsForPartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetColumnStatisticsForPartition, request, handler, context);
        }
 
        virtual Model::GetColumnStatisticsForTableOutcome GetColumnStatisticsForTable(const Model::GetColumnStatisticsForTableRequest& request) const;
 
        template<typename GetColumnStatisticsForTableRequestT = Model::GetColumnStatisticsForTableRequest>
        Model::GetColumnStatisticsForTableOutcomeCallable GetColumnStatisticsForTableCallable(const GetColumnStatisticsForTableRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetColumnStatisticsForTable, request);
        }
 
        template<typename GetColumnStatisticsForTableRequestT = Model::GetColumnStatisticsForTableRequest>
        void GetColumnStatisticsForTableAsync(const GetColumnStatisticsForTableRequestT& request, const GetColumnStatisticsForTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetColumnStatisticsForTable, request, handler, context);
        }
 
        virtual Model::GetColumnStatisticsTaskRunOutcome GetColumnStatisticsTaskRun(const Model::GetColumnStatisticsTaskRunRequest& request) const;
 
        template<typename GetColumnStatisticsTaskRunRequestT = Model::GetColumnStatisticsTaskRunRequest>
        Model::GetColumnStatisticsTaskRunOutcomeCallable GetColumnStatisticsTaskRunCallable(const GetColumnStatisticsTaskRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetColumnStatisticsTaskRun, request);
        }
 
        template<typename GetColumnStatisticsTaskRunRequestT = Model::GetColumnStatisticsTaskRunRequest>
        void GetColumnStatisticsTaskRunAsync(const GetColumnStatisticsTaskRunRequestT& request, const GetColumnStatisticsTaskRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetColumnStatisticsTaskRun, request, handler, context);
        }
 
        virtual Model::GetColumnStatisticsTaskRunsOutcome GetColumnStatisticsTaskRuns(const Model::GetColumnStatisticsTaskRunsRequest& request) const;
 
        template<typename GetColumnStatisticsTaskRunsRequestT = Model::GetColumnStatisticsTaskRunsRequest>
        Model::GetColumnStatisticsTaskRunsOutcomeCallable GetColumnStatisticsTaskRunsCallable(const GetColumnStatisticsTaskRunsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetColumnStatisticsTaskRuns, request);
        }
 
        template<typename GetColumnStatisticsTaskRunsRequestT = Model::GetColumnStatisticsTaskRunsRequest>
        void GetColumnStatisticsTaskRunsAsync(const GetColumnStatisticsTaskRunsRequestT& request, const GetColumnStatisticsTaskRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetColumnStatisticsTaskRuns, request, handler, context);
        }
 
        virtual Model::GetColumnStatisticsTaskSettingsOutcome GetColumnStatisticsTaskSettings(const Model::GetColumnStatisticsTaskSettingsRequest& request) const;
 
        template<typename GetColumnStatisticsTaskSettingsRequestT = Model::GetColumnStatisticsTaskSettingsRequest>
        Model::GetColumnStatisticsTaskSettingsOutcomeCallable GetColumnStatisticsTaskSettingsCallable(const GetColumnStatisticsTaskSettingsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetColumnStatisticsTaskSettings, request);
        }
 
        template<typename GetColumnStatisticsTaskSettingsRequestT = Model::GetColumnStatisticsTaskSettingsRequest>
        void GetColumnStatisticsTaskSettingsAsync(const GetColumnStatisticsTaskSettingsRequestT& request, const GetColumnStatisticsTaskSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetColumnStatisticsTaskSettings, request, handler, context);
        }
 
        virtual Model::GetConnectionOutcome GetConnection(const Model::GetConnectionRequest& request) const;
 
        template<typename GetConnectionRequestT = Model::GetConnectionRequest>
        Model::GetConnectionOutcomeCallable GetConnectionCallable(const GetConnectionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetConnection, request);
        }
 
        template<typename GetConnectionRequestT = Model::GetConnectionRequest>
        void GetConnectionAsync(const GetConnectionRequestT& request, const GetConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetConnection, request, handler, context);
        }
 
        virtual Model::GetConnectionsOutcome GetConnections(const Model::GetConnectionsRequest& request = {}) const;
 
        template<typename GetConnectionsRequestT = Model::GetConnectionsRequest>
        Model::GetConnectionsOutcomeCallable GetConnectionsCallable(const GetConnectionsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetConnections, request);
        }
 
        template<typename GetConnectionsRequestT = Model::GetConnectionsRequest>
        void GetConnectionsAsync(const GetConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetConnectionsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetConnections, request, handler, context);
        }
 
        virtual Model::GetCrawlerOutcome GetCrawler(const Model::GetCrawlerRequest& request) const;
 
        template<typename GetCrawlerRequestT = Model::GetCrawlerRequest>
        Model::GetCrawlerOutcomeCallable GetCrawlerCallable(const GetCrawlerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetCrawler, request);
        }
 
        template<typename GetCrawlerRequestT = Model::GetCrawlerRequest>
        void GetCrawlerAsync(const GetCrawlerRequestT& request, const GetCrawlerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetCrawler, request, handler, context);
        }
 
        virtual Model::GetCrawlerMetricsOutcome GetCrawlerMetrics(const Model::GetCrawlerMetricsRequest& request = {}) const;
 
        template<typename GetCrawlerMetricsRequestT = Model::GetCrawlerMetricsRequest>
        Model::GetCrawlerMetricsOutcomeCallable GetCrawlerMetricsCallable(const GetCrawlerMetricsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetCrawlerMetrics, request);
        }
 
        template<typename GetCrawlerMetricsRequestT = Model::GetCrawlerMetricsRequest>
        void GetCrawlerMetricsAsync(const GetCrawlerMetricsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetCrawlerMetricsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetCrawlerMetrics, request, handler, context);
        }
 
        virtual Model::GetCrawlersOutcome GetCrawlers(const Model::GetCrawlersRequest& request = {}) const;
 
        template<typename GetCrawlersRequestT = Model::GetCrawlersRequest>
        Model::GetCrawlersOutcomeCallable GetCrawlersCallable(const GetCrawlersRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetCrawlers, request);
        }
 
        template<typename GetCrawlersRequestT = Model::GetCrawlersRequest>
        void GetCrawlersAsync(const GetCrawlersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetCrawlersRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetCrawlers, request, handler, context);
        }
 
        virtual Model::GetCustomEntityTypeOutcome GetCustomEntityType(const Model::GetCustomEntityTypeRequest& request) const;
 
        template<typename GetCustomEntityTypeRequestT = Model::GetCustomEntityTypeRequest>
        Model::GetCustomEntityTypeOutcomeCallable GetCustomEntityTypeCallable(const GetCustomEntityTypeRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetCustomEntityType, request);
        }
 
        template<typename GetCustomEntityTypeRequestT = Model::GetCustomEntityTypeRequest>
        void GetCustomEntityTypeAsync(const GetCustomEntityTypeRequestT& request, const GetCustomEntityTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetCustomEntityType, request, handler, context);
        }
 
        virtual Model::GetDataCatalogEncryptionSettingsOutcome GetDataCatalogEncryptionSettings(const Model::GetDataCatalogEncryptionSettingsRequest& request = {}) const;
 
        template<typename GetDataCatalogEncryptionSettingsRequestT = Model::GetDataCatalogEncryptionSettingsRequest>
        Model::GetDataCatalogEncryptionSettingsOutcomeCallable GetDataCatalogEncryptionSettingsCallable(const GetDataCatalogEncryptionSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetDataCatalogEncryptionSettings, request);
        }
 
        template<typename GetDataCatalogEncryptionSettingsRequestT = Model::GetDataCatalogEncryptionSettingsRequest>
        void GetDataCatalogEncryptionSettingsAsync(const GetDataCatalogEncryptionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDataCatalogEncryptionSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetDataCatalogEncryptionSettings, request, handler, context);
        }
 
        virtual Model::GetDataQualityModelOutcome GetDataQualityModel(const Model::GetDataQualityModelRequest& request) const;
 
        template<typename GetDataQualityModelRequestT = Model::GetDataQualityModelRequest>
        Model::GetDataQualityModelOutcomeCallable GetDataQualityModelCallable(const GetDataQualityModelRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetDataQualityModel, request);
        }
 
        template<typename GetDataQualityModelRequestT = Model::GetDataQualityModelRequest>
        void GetDataQualityModelAsync(const GetDataQualityModelRequestT& request, const GetDataQualityModelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetDataQualityModel, request, handler, context);
        }
 
        virtual Model::GetDataQualityModelResultOutcome GetDataQualityModelResult(const Model::GetDataQualityModelResultRequest& request) const;
 
        template<typename GetDataQualityModelResultRequestT = Model::GetDataQualityModelResultRequest>
        Model::GetDataQualityModelResultOutcomeCallable GetDataQualityModelResultCallable(const GetDataQualityModelResultRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetDataQualityModelResult, request);
        }
 
        template<typename GetDataQualityModelResultRequestT = Model::GetDataQualityModelResultRequest>
        void GetDataQualityModelResultAsync(const GetDataQualityModelResultRequestT& request, const GetDataQualityModelResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetDataQualityModelResult, request, handler, context);
        }
 
        virtual Model::GetDataQualityResultOutcome GetDataQualityResult(const Model::GetDataQualityResultRequest& request) const;
 
        template<typename GetDataQualityResultRequestT = Model::GetDataQualityResultRequest>
        Model::GetDataQualityResultOutcomeCallable GetDataQualityResultCallable(const GetDataQualityResultRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetDataQualityResult, request);
        }
 
        template<typename GetDataQualityResultRequestT = Model::GetDataQualityResultRequest>
        void GetDataQualityResultAsync(const GetDataQualityResultRequestT& request, const GetDataQualityResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetDataQualityResult, request, handler, context);
        }
 
        virtual Model::GetDataQualityRuleRecommendationRunOutcome GetDataQualityRuleRecommendationRun(const Model::GetDataQualityRuleRecommendationRunRequest& request) const;
 
        template<typename GetDataQualityRuleRecommendationRunRequestT = Model::GetDataQualityRuleRecommendationRunRequest>
        Model::GetDataQualityRuleRecommendationRunOutcomeCallable GetDataQualityRuleRecommendationRunCallable(const GetDataQualityRuleRecommendationRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetDataQualityRuleRecommendationRun, request);
        }
 
        template<typename GetDataQualityRuleRecommendationRunRequestT = Model::GetDataQualityRuleRecommendationRunRequest>
        void GetDataQualityRuleRecommendationRunAsync(const GetDataQualityRuleRecommendationRunRequestT& request, const GetDataQualityRuleRecommendationRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetDataQualityRuleRecommendationRun, request, handler, context);
        }
 
        virtual Model::GetDataQualityRulesetOutcome GetDataQualityRuleset(const Model::GetDataQualityRulesetRequest& request) const;
 
        template<typename GetDataQualityRulesetRequestT = Model::GetDataQualityRulesetRequest>
        Model::GetDataQualityRulesetOutcomeCallable GetDataQualityRulesetCallable(const GetDataQualityRulesetRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetDataQualityRuleset, request);
        }
 
        template<typename GetDataQualityRulesetRequestT = Model::GetDataQualityRulesetRequest>
        void GetDataQualityRulesetAsync(const GetDataQualityRulesetRequestT& request, const GetDataQualityRulesetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetDataQualityRuleset, request, handler, context);
        }
 
        virtual Model::GetDataQualityRulesetEvaluationRunOutcome GetDataQualityRulesetEvaluationRun(const Model::GetDataQualityRulesetEvaluationRunRequest& request) const;
 
        template<typename GetDataQualityRulesetEvaluationRunRequestT = Model::GetDataQualityRulesetEvaluationRunRequest>
        Model::GetDataQualityRulesetEvaluationRunOutcomeCallable GetDataQualityRulesetEvaluationRunCallable(const GetDataQualityRulesetEvaluationRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetDataQualityRulesetEvaluationRun, request);
        }
 
        template<typename GetDataQualityRulesetEvaluationRunRequestT = Model::GetDataQualityRulesetEvaluationRunRequest>
        void GetDataQualityRulesetEvaluationRunAsync(const GetDataQualityRulesetEvaluationRunRequestT& request, const GetDataQualityRulesetEvaluationRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetDataQualityRulesetEvaluationRun, request, handler, context);
        }
 
        virtual Model::GetDatabaseOutcome GetDatabase(const Model::GetDatabaseRequest& request) const;
 
        template<typename GetDatabaseRequestT = Model::GetDatabaseRequest>
        Model::GetDatabaseOutcomeCallable GetDatabaseCallable(const GetDatabaseRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetDatabase, request);
        }
 
        template<typename GetDatabaseRequestT = Model::GetDatabaseRequest>
        void GetDatabaseAsync(const GetDatabaseRequestT& request, const GetDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetDatabase, request, handler, context);
        }
 
        virtual Model::GetDatabasesOutcome GetDatabases(const Model::GetDatabasesRequest& request = {}) const;
 
        template<typename GetDatabasesRequestT = Model::GetDatabasesRequest>
        Model::GetDatabasesOutcomeCallable GetDatabasesCallable(const GetDatabasesRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetDatabases, request);
        }
 
        template<typename GetDatabasesRequestT = Model::GetDatabasesRequest>
        void GetDatabasesAsync(const GetDatabasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDatabasesRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetDatabases, request, handler, context);
        }
 
        virtual Model::GetDataflowGraphOutcome GetDataflowGraph(const Model::GetDataflowGraphRequest& request = {}) const;
 
        template<typename GetDataflowGraphRequestT = Model::GetDataflowGraphRequest>
        Model::GetDataflowGraphOutcomeCallable GetDataflowGraphCallable(const GetDataflowGraphRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetDataflowGraph, request);
        }
 
        template<typename GetDataflowGraphRequestT = Model::GetDataflowGraphRequest>
        void GetDataflowGraphAsync(const GetDataflowGraphResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDataflowGraphRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetDataflowGraph, request, handler, context);
        }
 
        virtual Model::GetDevEndpointOutcome GetDevEndpoint(const Model::GetDevEndpointRequest& request) const;
 
        template<typename GetDevEndpointRequestT = Model::GetDevEndpointRequest>
        Model::GetDevEndpointOutcomeCallable GetDevEndpointCallable(const GetDevEndpointRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetDevEndpoint, request);
        }
 
        template<typename GetDevEndpointRequestT = Model::GetDevEndpointRequest>
        void GetDevEndpointAsync(const GetDevEndpointRequestT& request, const GetDevEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetDevEndpoint, request, handler, context);
        }
 
        virtual Model::GetDevEndpointsOutcome GetDevEndpoints(const Model::GetDevEndpointsRequest& request = {}) const;
 
        template<typename GetDevEndpointsRequestT = Model::GetDevEndpointsRequest>
        Model::GetDevEndpointsOutcomeCallable GetDevEndpointsCallable(const GetDevEndpointsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetDevEndpoints, request);
        }
 
        template<typename GetDevEndpointsRequestT = Model::GetDevEndpointsRequest>
        void GetDevEndpointsAsync(const GetDevEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDevEndpointsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetDevEndpoints, request, handler, context);
        }
 
        virtual Model::GetEntityRecordsOutcome GetEntityRecords(const Model::GetEntityRecordsRequest& request) const;
 
        template<typename GetEntityRecordsRequestT = Model::GetEntityRecordsRequest>
        Model::GetEntityRecordsOutcomeCallable GetEntityRecordsCallable(const GetEntityRecordsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetEntityRecords, request);
        }
 
        template<typename GetEntityRecordsRequestT = Model::GetEntityRecordsRequest>
        void GetEntityRecordsAsync(const GetEntityRecordsRequestT& request, const GetEntityRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetEntityRecords, request, handler, context);
        }
 
        virtual Model::GetGlueIdentityCenterConfigurationOutcome GetGlueIdentityCenterConfiguration(const Model::GetGlueIdentityCenterConfigurationRequest& request = {}) const;
 
        template<typename GetGlueIdentityCenterConfigurationRequestT = Model::GetGlueIdentityCenterConfigurationRequest>
        Model::GetGlueIdentityCenterConfigurationOutcomeCallable GetGlueIdentityCenterConfigurationCallable(const GetGlueIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetGlueIdentityCenterConfiguration, request);
        }
 
        template<typename GetGlueIdentityCenterConfigurationRequestT = Model::GetGlueIdentityCenterConfigurationRequest>
        void GetGlueIdentityCenterConfigurationAsync(const GetGlueIdentityCenterConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetGlueIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetGlueIdentityCenterConfiguration, request, handler, context);
        }
 
        virtual Model::GetIntegrationResourcePropertyOutcome GetIntegrationResourceProperty(const Model::GetIntegrationResourcePropertyRequest& request) const;
 
        template<typename GetIntegrationResourcePropertyRequestT = Model::GetIntegrationResourcePropertyRequest>
        Model::GetIntegrationResourcePropertyOutcomeCallable GetIntegrationResourcePropertyCallable(const GetIntegrationResourcePropertyRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetIntegrationResourceProperty, request);
        }
 
        template<typename GetIntegrationResourcePropertyRequestT = Model::GetIntegrationResourcePropertyRequest>
        void GetIntegrationResourcePropertyAsync(const GetIntegrationResourcePropertyRequestT& request, const GetIntegrationResourcePropertyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetIntegrationResourceProperty, request, handler, context);
        }
 
        virtual Model::GetIntegrationTablePropertiesOutcome GetIntegrationTableProperties(const Model::GetIntegrationTablePropertiesRequest& request) const;
 
        template<typename GetIntegrationTablePropertiesRequestT = Model::GetIntegrationTablePropertiesRequest>
        Model::GetIntegrationTablePropertiesOutcomeCallable GetIntegrationTablePropertiesCallable(const GetIntegrationTablePropertiesRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetIntegrationTableProperties, request);
        }
 
        template<typename GetIntegrationTablePropertiesRequestT = Model::GetIntegrationTablePropertiesRequest>
        void GetIntegrationTablePropertiesAsync(const GetIntegrationTablePropertiesRequestT& request, const GetIntegrationTablePropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetIntegrationTableProperties, request, handler, context);
        }
 
        virtual Model::GetJobOutcome GetJob(const Model::GetJobRequest& request) const;
 
        template<typename GetJobRequestT = Model::GetJobRequest>
        Model::GetJobOutcomeCallable GetJobCallable(const GetJobRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetJob, request);
        }
 
        template<typename GetJobRequestT = Model::GetJobRequest>
        void GetJobAsync(const GetJobRequestT& request, const GetJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetJob, request, handler, context);
        }
 
        virtual Model::GetJobBookmarkOutcome GetJobBookmark(const Model::GetJobBookmarkRequest& request) const;
 
        template<typename GetJobBookmarkRequestT = Model::GetJobBookmarkRequest>
        Model::GetJobBookmarkOutcomeCallable GetJobBookmarkCallable(const GetJobBookmarkRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetJobBookmark, request);
        }
 
        template<typename GetJobBookmarkRequestT = Model::GetJobBookmarkRequest>
        void GetJobBookmarkAsync(const GetJobBookmarkRequestT& request, const GetJobBookmarkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetJobBookmark, request, handler, context);
        }
 
        virtual Model::GetJobRunOutcome GetJobRun(const Model::GetJobRunRequest& request) const;
 
        template<typename GetJobRunRequestT = Model::GetJobRunRequest>
        Model::GetJobRunOutcomeCallable GetJobRunCallable(const GetJobRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetJobRun, request);
        }
 
        template<typename GetJobRunRequestT = Model::GetJobRunRequest>
        void GetJobRunAsync(const GetJobRunRequestT& request, const GetJobRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetJobRun, request, handler, context);
        }
 
        virtual Model::GetJobRunsOutcome GetJobRuns(const Model::GetJobRunsRequest& request) const;
 
        template<typename GetJobRunsRequestT = Model::GetJobRunsRequest>
        Model::GetJobRunsOutcomeCallable GetJobRunsCallable(const GetJobRunsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetJobRuns, request);
        }
 
        template<typename GetJobRunsRequestT = Model::GetJobRunsRequest>
        void GetJobRunsAsync(const GetJobRunsRequestT& request, const GetJobRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetJobRuns, request, handler, context);
        }
 
        virtual Model::GetJobsOutcome GetJobs(const Model::GetJobsRequest& request = {}) const;
 
        template<typename GetJobsRequestT = Model::GetJobsRequest>
        Model::GetJobsOutcomeCallable GetJobsCallable(const GetJobsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetJobs, request);
        }
 
        template<typename GetJobsRequestT = Model::GetJobsRequest>
        void GetJobsAsync(const GetJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetJobsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetJobs, request, handler, context);
        }
 
        virtual Model::GetMLTaskRunOutcome GetMLTaskRun(const Model::GetMLTaskRunRequest& request) const;
 
        template<typename GetMLTaskRunRequestT = Model::GetMLTaskRunRequest>
        Model::GetMLTaskRunOutcomeCallable GetMLTaskRunCallable(const GetMLTaskRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetMLTaskRun, request);
        }
 
        template<typename GetMLTaskRunRequestT = Model::GetMLTaskRunRequest>
        void GetMLTaskRunAsync(const GetMLTaskRunRequestT& request, const GetMLTaskRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetMLTaskRun, request, handler, context);
        }
 
        virtual Model::GetMLTaskRunsOutcome GetMLTaskRuns(const Model::GetMLTaskRunsRequest& request) const;
 
        template<typename GetMLTaskRunsRequestT = Model::GetMLTaskRunsRequest>
        Model::GetMLTaskRunsOutcomeCallable GetMLTaskRunsCallable(const GetMLTaskRunsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetMLTaskRuns, request);
        }
 
        template<typename GetMLTaskRunsRequestT = Model::GetMLTaskRunsRequest>
        void GetMLTaskRunsAsync(const GetMLTaskRunsRequestT& request, const GetMLTaskRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetMLTaskRuns, request, handler, context);
        }
 
        virtual Model::GetMLTransformOutcome GetMLTransform(const Model::GetMLTransformRequest& request) const;
 
        template<typename GetMLTransformRequestT = Model::GetMLTransformRequest>
        Model::GetMLTransformOutcomeCallable GetMLTransformCallable(const GetMLTransformRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetMLTransform, request);
        }
 
        template<typename GetMLTransformRequestT = Model::GetMLTransformRequest>
        void GetMLTransformAsync(const GetMLTransformRequestT& request, const GetMLTransformResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetMLTransform, request, handler, context);
        }
 
        virtual Model::GetMLTransformsOutcome GetMLTransforms(const Model::GetMLTransformsRequest& request = {}) const;
 
        template<typename GetMLTransformsRequestT = Model::GetMLTransformsRequest>
        Model::GetMLTransformsOutcomeCallable GetMLTransformsCallable(const GetMLTransformsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetMLTransforms, request);
        }
 
        template<typename GetMLTransformsRequestT = Model::GetMLTransformsRequest>
        void GetMLTransformsAsync(const GetMLTransformsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetMLTransformsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetMLTransforms, request, handler, context);
        }
 
        virtual Model::GetMappingOutcome GetMapping(const Model::GetMappingRequest& request) const;
 
        template<typename GetMappingRequestT = Model::GetMappingRequest>
        Model::GetMappingOutcomeCallable GetMappingCallable(const GetMappingRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetMapping, request);
        }
 
        template<typename GetMappingRequestT = Model::GetMappingRequest>
        void GetMappingAsync(const GetMappingRequestT& request, const GetMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetMapping, request, handler, context);
        }
 
        virtual Model::GetPartitionOutcome GetPartition(const Model::GetPartitionRequest& request) const;
 
        template<typename GetPartitionRequestT = Model::GetPartitionRequest>
        Model::GetPartitionOutcomeCallable GetPartitionCallable(const GetPartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetPartition, request);
        }
 
        template<typename GetPartitionRequestT = Model::GetPartitionRequest>
        void GetPartitionAsync(const GetPartitionRequestT& request, const GetPartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetPartition, request, handler, context);
        }
 
        virtual Model::GetPartitionIndexesOutcome GetPartitionIndexes(const Model::GetPartitionIndexesRequest& request) const;
 
        template<typename GetPartitionIndexesRequestT = Model::GetPartitionIndexesRequest>
        Model::GetPartitionIndexesOutcomeCallable GetPartitionIndexesCallable(const GetPartitionIndexesRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetPartitionIndexes, request);
        }
 
        template<typename GetPartitionIndexesRequestT = Model::GetPartitionIndexesRequest>
        void GetPartitionIndexesAsync(const GetPartitionIndexesRequestT& request, const GetPartitionIndexesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetPartitionIndexes, request, handler, context);
        }
 
        virtual Model::GetPartitionsOutcome GetPartitions(const Model::GetPartitionsRequest& request) const;
 
        template<typename GetPartitionsRequestT = Model::GetPartitionsRequest>
        Model::GetPartitionsOutcomeCallable GetPartitionsCallable(const GetPartitionsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetPartitions, request);
        }
 
        template<typename GetPartitionsRequestT = Model::GetPartitionsRequest>
        void GetPartitionsAsync(const GetPartitionsRequestT& request, const GetPartitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetPartitions, request, handler, context);
        }
 
        virtual Model::GetPlanOutcome GetPlan(const Model::GetPlanRequest& request) const;
 
        template<typename GetPlanRequestT = Model::GetPlanRequest>
        Model::GetPlanOutcomeCallable GetPlanCallable(const GetPlanRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetPlan, request);
        }
 
        template<typename GetPlanRequestT = Model::GetPlanRequest>
        void GetPlanAsync(const GetPlanRequestT& request, const GetPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetPlan, request, handler, context);
        }
 
        virtual Model::GetRegistryOutcome GetRegistry(const Model::GetRegistryRequest& request) const;
 
        template<typename GetRegistryRequestT = Model::GetRegistryRequest>
        Model::GetRegistryOutcomeCallable GetRegistryCallable(const GetRegistryRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetRegistry, request);
        }
 
        template<typename GetRegistryRequestT = Model::GetRegistryRequest>
        void GetRegistryAsync(const GetRegistryRequestT& request, const GetRegistryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetRegistry, request, handler, context);
        }
 
        virtual Model::GetResourcePoliciesOutcome GetResourcePolicies(const Model::GetResourcePoliciesRequest& request = {}) const;
 
        template<typename GetResourcePoliciesRequestT = Model::GetResourcePoliciesRequest>
        Model::GetResourcePoliciesOutcomeCallable GetResourcePoliciesCallable(const GetResourcePoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetResourcePolicies, request);
        }
 
        template<typename GetResourcePoliciesRequestT = Model::GetResourcePoliciesRequest>
        void GetResourcePoliciesAsync(const GetResourcePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetResourcePoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetResourcePolicies, request, handler, context);
        }
 
        virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request = {}) const;
 
        template<typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
        Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetResourcePolicy, request);
        }
 
        template<typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
        void GetResourcePolicyAsync(const GetResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetResourcePolicyRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetResourcePolicy, request, handler, context);
        }
 
        virtual Model::GetSchemaOutcome GetSchema(const Model::GetSchemaRequest& request) const;
 
        template<typename GetSchemaRequestT = Model::GetSchemaRequest>
        Model::GetSchemaOutcomeCallable GetSchemaCallable(const GetSchemaRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetSchema, request);
        }
 
        template<typename GetSchemaRequestT = Model::GetSchemaRequest>
        void GetSchemaAsync(const GetSchemaRequestT& request, const GetSchemaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetSchema, request, handler, context);
        }
 
        virtual Model::GetSchemaByDefinitionOutcome GetSchemaByDefinition(const Model::GetSchemaByDefinitionRequest& request) const;
 
        template<typename GetSchemaByDefinitionRequestT = Model::GetSchemaByDefinitionRequest>
        Model::GetSchemaByDefinitionOutcomeCallable GetSchemaByDefinitionCallable(const GetSchemaByDefinitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetSchemaByDefinition, request);
        }
 
        template<typename GetSchemaByDefinitionRequestT = Model::GetSchemaByDefinitionRequest>
        void GetSchemaByDefinitionAsync(const GetSchemaByDefinitionRequestT& request, const GetSchemaByDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetSchemaByDefinition, request, handler, context);
        }
 
        virtual Model::GetSchemaVersionOutcome GetSchemaVersion(const Model::GetSchemaVersionRequest& request = {}) const;
 
        template<typename GetSchemaVersionRequestT = Model::GetSchemaVersionRequest>
        Model::GetSchemaVersionOutcomeCallable GetSchemaVersionCallable(const GetSchemaVersionRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetSchemaVersion, request);
        }
 
        template<typename GetSchemaVersionRequestT = Model::GetSchemaVersionRequest>
        void GetSchemaVersionAsync(const GetSchemaVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSchemaVersionRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetSchemaVersion, request, handler, context);
        }
 
        virtual Model::GetSchemaVersionsDiffOutcome GetSchemaVersionsDiff(const Model::GetSchemaVersionsDiffRequest& request) const;
 
        template<typename GetSchemaVersionsDiffRequestT = Model::GetSchemaVersionsDiffRequest>
        Model::GetSchemaVersionsDiffOutcomeCallable GetSchemaVersionsDiffCallable(const GetSchemaVersionsDiffRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetSchemaVersionsDiff, request);
        }
 
        template<typename GetSchemaVersionsDiffRequestT = Model::GetSchemaVersionsDiffRequest>
        void GetSchemaVersionsDiffAsync(const GetSchemaVersionsDiffRequestT& request, const GetSchemaVersionsDiffResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetSchemaVersionsDiff, request, handler, context);
        }
 
        virtual Model::GetSecurityConfigurationOutcome GetSecurityConfiguration(const Model::GetSecurityConfigurationRequest& request) const;
 
        template<typename GetSecurityConfigurationRequestT = Model::GetSecurityConfigurationRequest>
        Model::GetSecurityConfigurationOutcomeCallable GetSecurityConfigurationCallable(const GetSecurityConfigurationRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetSecurityConfiguration, request);
        }
 
        template<typename GetSecurityConfigurationRequestT = Model::GetSecurityConfigurationRequest>
        void GetSecurityConfigurationAsync(const GetSecurityConfigurationRequestT& request, const GetSecurityConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetSecurityConfiguration, request, handler, context);
        }
 
        virtual Model::GetSecurityConfigurationsOutcome GetSecurityConfigurations(const Model::GetSecurityConfigurationsRequest& request = {}) const;
 
        template<typename GetSecurityConfigurationsRequestT = Model::GetSecurityConfigurationsRequest>
        Model::GetSecurityConfigurationsOutcomeCallable GetSecurityConfigurationsCallable(const GetSecurityConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetSecurityConfigurations, request);
        }
 
        template<typename GetSecurityConfigurationsRequestT = Model::GetSecurityConfigurationsRequest>
        void GetSecurityConfigurationsAsync(const GetSecurityConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSecurityConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetSecurityConfigurations, request, handler, context);
        }
 
        virtual Model::GetSessionOutcome GetSession(const Model::GetSessionRequest& request) const;
 
        template<typename GetSessionRequestT = Model::GetSessionRequest>
        Model::GetSessionOutcomeCallable GetSessionCallable(const GetSessionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetSession, request);
        }
 
        template<typename GetSessionRequestT = Model::GetSessionRequest>
        void GetSessionAsync(const GetSessionRequestT& request, const GetSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetSession, request, handler, context);
        }
 
        virtual Model::GetStatementOutcome GetStatement(const Model::GetStatementRequest& request) const;
 
        template<typename GetStatementRequestT = Model::GetStatementRequest>
        Model::GetStatementOutcomeCallable GetStatementCallable(const GetStatementRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetStatement, request);
        }
 
        template<typename GetStatementRequestT = Model::GetStatementRequest>
        void GetStatementAsync(const GetStatementRequestT& request, const GetStatementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetStatement, request, handler, context);
        }
 
        virtual Model::GetTableOutcome GetTable(const Model::GetTableRequest& request) const;
 
        template<typename GetTableRequestT = Model::GetTableRequest>
        Model::GetTableOutcomeCallable GetTableCallable(const GetTableRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetTable, request);
        }
 
        template<typename GetTableRequestT = Model::GetTableRequest>
        void GetTableAsync(const GetTableRequestT& request, const GetTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetTable, request, handler, context);
        }
 
        virtual Model::GetTableOptimizerOutcome GetTableOptimizer(const Model::GetTableOptimizerRequest& request) const;
 
        template<typename GetTableOptimizerRequestT = Model::GetTableOptimizerRequest>
        Model::GetTableOptimizerOutcomeCallable GetTableOptimizerCallable(const GetTableOptimizerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetTableOptimizer, request);
        }
 
        template<typename GetTableOptimizerRequestT = Model::GetTableOptimizerRequest>
        void GetTableOptimizerAsync(const GetTableOptimizerRequestT& request, const GetTableOptimizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetTableOptimizer, request, handler, context);
        }
 
        virtual Model::GetTableVersionOutcome GetTableVersion(const Model::GetTableVersionRequest& request) const;
 
        template<typename GetTableVersionRequestT = Model::GetTableVersionRequest>
        Model::GetTableVersionOutcomeCallable GetTableVersionCallable(const GetTableVersionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetTableVersion, request);
        }
 
        template<typename GetTableVersionRequestT = Model::GetTableVersionRequest>
        void GetTableVersionAsync(const GetTableVersionRequestT& request, const GetTableVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetTableVersion, request, handler, context);
        }
 
        virtual Model::GetTableVersionsOutcome GetTableVersions(const Model::GetTableVersionsRequest& request) const;
 
        template<typename GetTableVersionsRequestT = Model::GetTableVersionsRequest>
        Model::GetTableVersionsOutcomeCallable GetTableVersionsCallable(const GetTableVersionsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetTableVersions, request);
        }
 
        template<typename GetTableVersionsRequestT = Model::GetTableVersionsRequest>
        void GetTableVersionsAsync(const GetTableVersionsRequestT& request, const GetTableVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetTableVersions, request, handler, context);
        }
 
        virtual Model::GetTablesOutcome GetTables(const Model::GetTablesRequest& request) const;
 
        template<typename GetTablesRequestT = Model::GetTablesRequest>
        Model::GetTablesOutcomeCallable GetTablesCallable(const GetTablesRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetTables, request);
        }
 
        template<typename GetTablesRequestT = Model::GetTablesRequest>
        void GetTablesAsync(const GetTablesRequestT& request, const GetTablesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetTables, request, handler, context);
        }
 
        virtual Model::GetTagsOutcome GetTags(const Model::GetTagsRequest& request) const;
 
        template<typename GetTagsRequestT = Model::GetTagsRequest>
        Model::GetTagsOutcomeCallable GetTagsCallable(const GetTagsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetTags, request);
        }
 
        template<typename GetTagsRequestT = Model::GetTagsRequest>
        void GetTagsAsync(const GetTagsRequestT& request, const GetTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetTags, request, handler, context);
        }
 
        virtual Model::GetTriggerOutcome GetTrigger(const Model::GetTriggerRequest& request) const;
 
        template<typename GetTriggerRequestT = Model::GetTriggerRequest>
        Model::GetTriggerOutcomeCallable GetTriggerCallable(const GetTriggerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetTrigger, request);
        }
 
        template<typename GetTriggerRequestT = Model::GetTriggerRequest>
        void GetTriggerAsync(const GetTriggerRequestT& request, const GetTriggerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetTrigger, request, handler, context);
        }
 
        virtual Model::GetTriggersOutcome GetTriggers(const Model::GetTriggersRequest& request = {}) const;
 
        template<typename GetTriggersRequestT = Model::GetTriggersRequest>
        Model::GetTriggersOutcomeCallable GetTriggersCallable(const GetTriggersRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::GetTriggers, request);
        }
 
        template<typename GetTriggersRequestT = Model::GetTriggersRequest>
        void GetTriggersAsync(const GetTriggersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetTriggersRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::GetTriggers, request, handler, context);
        }
 
        virtual Model::GetUnfilteredPartitionMetadataOutcome GetUnfilteredPartitionMetadata(const Model::GetUnfilteredPartitionMetadataRequest& request) const;
 
        template<typename GetUnfilteredPartitionMetadataRequestT = Model::GetUnfilteredPartitionMetadataRequest>
        Model::GetUnfilteredPartitionMetadataOutcomeCallable GetUnfilteredPartitionMetadataCallable(const GetUnfilteredPartitionMetadataRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetUnfilteredPartitionMetadata, request);
        }
 
        template<typename GetUnfilteredPartitionMetadataRequestT = Model::GetUnfilteredPartitionMetadataRequest>
        void GetUnfilteredPartitionMetadataAsync(const GetUnfilteredPartitionMetadataRequestT& request, const GetUnfilteredPartitionMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetUnfilteredPartitionMetadata, request, handler, context);
        }
 
        virtual Model::GetUnfilteredPartitionsMetadataOutcome GetUnfilteredPartitionsMetadata(const Model::GetUnfilteredPartitionsMetadataRequest& request) const;
 
        template<typename GetUnfilteredPartitionsMetadataRequestT = Model::GetUnfilteredPartitionsMetadataRequest>
        Model::GetUnfilteredPartitionsMetadataOutcomeCallable GetUnfilteredPartitionsMetadataCallable(const GetUnfilteredPartitionsMetadataRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetUnfilteredPartitionsMetadata, request);
        }
 
        template<typename GetUnfilteredPartitionsMetadataRequestT = Model::GetUnfilteredPartitionsMetadataRequest>
        void GetUnfilteredPartitionsMetadataAsync(const GetUnfilteredPartitionsMetadataRequestT& request, const GetUnfilteredPartitionsMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetUnfilteredPartitionsMetadata, request, handler, context);
        }
 
        virtual Model::GetUnfilteredTableMetadataOutcome GetUnfilteredTableMetadata(const Model::GetUnfilteredTableMetadataRequest& request) const;
 
        template<typename GetUnfilteredTableMetadataRequestT = Model::GetUnfilteredTableMetadataRequest>
        Model::GetUnfilteredTableMetadataOutcomeCallable GetUnfilteredTableMetadataCallable(const GetUnfilteredTableMetadataRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetUnfilteredTableMetadata, request);
        }
 
        template<typename GetUnfilteredTableMetadataRequestT = Model::GetUnfilteredTableMetadataRequest>
        void GetUnfilteredTableMetadataAsync(const GetUnfilteredTableMetadataRequestT& request, const GetUnfilteredTableMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetUnfilteredTableMetadata, request, handler, context);
        }
 
        virtual Model::GetUsageProfileOutcome GetUsageProfile(const Model::GetUsageProfileRequest& request) const;
 
        template<typename GetUsageProfileRequestT = Model::GetUsageProfileRequest>
        Model::GetUsageProfileOutcomeCallable GetUsageProfileCallable(const GetUsageProfileRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetUsageProfile, request);
        }
 
        template<typename GetUsageProfileRequestT = Model::GetUsageProfileRequest>
        void GetUsageProfileAsync(const GetUsageProfileRequestT& request, const GetUsageProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetUsageProfile, request, handler, context);
        }
 
        virtual Model::GetUserDefinedFunctionOutcome GetUserDefinedFunction(const Model::GetUserDefinedFunctionRequest& request) const;
 
        template<typename GetUserDefinedFunctionRequestT = Model::GetUserDefinedFunctionRequest>
        Model::GetUserDefinedFunctionOutcomeCallable GetUserDefinedFunctionCallable(const GetUserDefinedFunctionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetUserDefinedFunction, request);
        }
 
        template<typename GetUserDefinedFunctionRequestT = Model::GetUserDefinedFunctionRequest>
        void GetUserDefinedFunctionAsync(const GetUserDefinedFunctionRequestT& request, const GetUserDefinedFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetUserDefinedFunction, request, handler, context);
        }
 
        virtual Model::GetUserDefinedFunctionsOutcome GetUserDefinedFunctions(const Model::GetUserDefinedFunctionsRequest& request) const;
 
        template<typename GetUserDefinedFunctionsRequestT = Model::GetUserDefinedFunctionsRequest>
        Model::GetUserDefinedFunctionsOutcomeCallable GetUserDefinedFunctionsCallable(const GetUserDefinedFunctionsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetUserDefinedFunctions, request);
        }
 
        template<typename GetUserDefinedFunctionsRequestT = Model::GetUserDefinedFunctionsRequest>
        void GetUserDefinedFunctionsAsync(const GetUserDefinedFunctionsRequestT& request, const GetUserDefinedFunctionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetUserDefinedFunctions, request, handler, context);
        }
 
        virtual Model::GetWorkflowOutcome GetWorkflow(const Model::GetWorkflowRequest& request) const;
 
        template<typename GetWorkflowRequestT = Model::GetWorkflowRequest>
        Model::GetWorkflowOutcomeCallable GetWorkflowCallable(const GetWorkflowRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetWorkflow, request);
        }
 
        template<typename GetWorkflowRequestT = Model::GetWorkflowRequest>
        void GetWorkflowAsync(const GetWorkflowRequestT& request, const GetWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetWorkflow, request, handler, context);
        }
 
        virtual Model::GetWorkflowRunOutcome GetWorkflowRun(const Model::GetWorkflowRunRequest& request) const;
 
        template<typename GetWorkflowRunRequestT = Model::GetWorkflowRunRequest>
        Model::GetWorkflowRunOutcomeCallable GetWorkflowRunCallable(const GetWorkflowRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetWorkflowRun, request);
        }
 
        template<typename GetWorkflowRunRequestT = Model::GetWorkflowRunRequest>
        void GetWorkflowRunAsync(const GetWorkflowRunRequestT& request, const GetWorkflowRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetWorkflowRun, request, handler, context);
        }
 
        virtual Model::GetWorkflowRunPropertiesOutcome GetWorkflowRunProperties(const Model::GetWorkflowRunPropertiesRequest& request) const;
 
        template<typename GetWorkflowRunPropertiesRequestT = Model::GetWorkflowRunPropertiesRequest>
        Model::GetWorkflowRunPropertiesOutcomeCallable GetWorkflowRunPropertiesCallable(const GetWorkflowRunPropertiesRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetWorkflowRunProperties, request);
        }
 
        template<typename GetWorkflowRunPropertiesRequestT = Model::GetWorkflowRunPropertiesRequest>
        void GetWorkflowRunPropertiesAsync(const GetWorkflowRunPropertiesRequestT& request, const GetWorkflowRunPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetWorkflowRunProperties, request, handler, context);
        }
 
        virtual Model::GetWorkflowRunsOutcome GetWorkflowRuns(const Model::GetWorkflowRunsRequest& request) const;
 
        template<typename GetWorkflowRunsRequestT = Model::GetWorkflowRunsRequest>
        Model::GetWorkflowRunsOutcomeCallable GetWorkflowRunsCallable(const GetWorkflowRunsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::GetWorkflowRuns, request);
        }
 
        template<typename GetWorkflowRunsRequestT = Model::GetWorkflowRunsRequest>
        void GetWorkflowRunsAsync(const GetWorkflowRunsRequestT& request, const GetWorkflowRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::GetWorkflowRuns, request, handler, context);
        }
 
        virtual Model::ImportCatalogToGlueOutcome ImportCatalogToGlue(const Model::ImportCatalogToGlueRequest& request = {}) const;
 
        template<typename ImportCatalogToGlueRequestT = Model::ImportCatalogToGlueRequest>
        Model::ImportCatalogToGlueOutcomeCallable ImportCatalogToGlueCallable(const ImportCatalogToGlueRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ImportCatalogToGlue, request);
        }
 
        template<typename ImportCatalogToGlueRequestT = Model::ImportCatalogToGlueRequest>
        void ImportCatalogToGlueAsync(const ImportCatalogToGlueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ImportCatalogToGlueRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ImportCatalogToGlue, request, handler, context);
        }
 
        virtual Model::ListBlueprintsOutcome ListBlueprints(const Model::ListBlueprintsRequest& request = {}) const;
 
        template<typename ListBlueprintsRequestT = Model::ListBlueprintsRequest>
        Model::ListBlueprintsOutcomeCallable ListBlueprintsCallable(const ListBlueprintsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListBlueprints, request);
        }
 
        template<typename ListBlueprintsRequestT = Model::ListBlueprintsRequest>
        void ListBlueprintsAsync(const ListBlueprintsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBlueprintsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListBlueprints, request, handler, context);
        }
 
        virtual Model::ListColumnStatisticsTaskRunsOutcome ListColumnStatisticsTaskRuns(const Model::ListColumnStatisticsTaskRunsRequest& request = {}) const;
 
        template<typename ListColumnStatisticsTaskRunsRequestT = Model::ListColumnStatisticsTaskRunsRequest>
        Model::ListColumnStatisticsTaskRunsOutcomeCallable ListColumnStatisticsTaskRunsCallable(const ListColumnStatisticsTaskRunsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListColumnStatisticsTaskRuns, request);
        }
 
        template<typename ListColumnStatisticsTaskRunsRequestT = Model::ListColumnStatisticsTaskRunsRequest>
        void ListColumnStatisticsTaskRunsAsync(const ListColumnStatisticsTaskRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListColumnStatisticsTaskRunsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListColumnStatisticsTaskRuns, request, handler, context);
        }
 
        virtual Model::ListConnectionTypesOutcome ListConnectionTypes(const Model::ListConnectionTypesRequest& request = {}) const;
 
        template<typename ListConnectionTypesRequestT = Model::ListConnectionTypesRequest>
        Model::ListConnectionTypesOutcomeCallable ListConnectionTypesCallable(const ListConnectionTypesRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListConnectionTypes, request);
        }
 
        template<typename ListConnectionTypesRequestT = Model::ListConnectionTypesRequest>
        void ListConnectionTypesAsync(const ListConnectionTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConnectionTypesRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListConnectionTypes, request, handler, context);
        }
 
        virtual Model::ListCrawlersOutcome ListCrawlers(const Model::ListCrawlersRequest& request = {}) const;
 
        template<typename ListCrawlersRequestT = Model::ListCrawlersRequest>
        Model::ListCrawlersOutcomeCallable ListCrawlersCallable(const ListCrawlersRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListCrawlers, request);
        }
 
        template<typename ListCrawlersRequestT = Model::ListCrawlersRequest>
        void ListCrawlersAsync(const ListCrawlersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCrawlersRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListCrawlers, request, handler, context);
        }
 
        virtual Model::ListCrawlsOutcome ListCrawls(const Model::ListCrawlsRequest& request) const;
 
        template<typename ListCrawlsRequestT = Model::ListCrawlsRequest>
        Model::ListCrawlsOutcomeCallable ListCrawlsCallable(const ListCrawlsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::ListCrawls, request);
        }
 
        template<typename ListCrawlsRequestT = Model::ListCrawlsRequest>
        void ListCrawlsAsync(const ListCrawlsRequestT& request, const ListCrawlsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::ListCrawls, request, handler, context);
        }
 
        virtual Model::ListCustomEntityTypesOutcome ListCustomEntityTypes(const Model::ListCustomEntityTypesRequest& request = {}) const;
 
        template<typename ListCustomEntityTypesRequestT = Model::ListCustomEntityTypesRequest>
        Model::ListCustomEntityTypesOutcomeCallable ListCustomEntityTypesCallable(const ListCustomEntityTypesRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListCustomEntityTypes, request);
        }
 
        template<typename ListCustomEntityTypesRequestT = Model::ListCustomEntityTypesRequest>
        void ListCustomEntityTypesAsync(const ListCustomEntityTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCustomEntityTypesRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListCustomEntityTypes, request, handler, context);
        }
 
        virtual Model::ListDataQualityResultsOutcome ListDataQualityResults(const Model::ListDataQualityResultsRequest& request = {}) const;
 
        template<typename ListDataQualityResultsRequestT = Model::ListDataQualityResultsRequest>
        Model::ListDataQualityResultsOutcomeCallable ListDataQualityResultsCallable(const ListDataQualityResultsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListDataQualityResults, request);
        }
 
        template<typename ListDataQualityResultsRequestT = Model::ListDataQualityResultsRequest>
        void ListDataQualityResultsAsync(const ListDataQualityResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataQualityResultsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListDataQualityResults, request, handler, context);
        }
 
        virtual Model::ListDataQualityRuleRecommendationRunsOutcome ListDataQualityRuleRecommendationRuns(const Model::ListDataQualityRuleRecommendationRunsRequest& request = {}) const;
 
        template<typename ListDataQualityRuleRecommendationRunsRequestT = Model::ListDataQualityRuleRecommendationRunsRequest>
        Model::ListDataQualityRuleRecommendationRunsOutcomeCallable ListDataQualityRuleRecommendationRunsCallable(const ListDataQualityRuleRecommendationRunsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListDataQualityRuleRecommendationRuns, request);
        }
 
        template<typename ListDataQualityRuleRecommendationRunsRequestT = Model::ListDataQualityRuleRecommendationRunsRequest>
        void ListDataQualityRuleRecommendationRunsAsync(const ListDataQualityRuleRecommendationRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataQualityRuleRecommendationRunsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListDataQualityRuleRecommendationRuns, request, handler, context);
        }
 
        virtual Model::ListDataQualityRulesetEvaluationRunsOutcome ListDataQualityRulesetEvaluationRuns(const Model::ListDataQualityRulesetEvaluationRunsRequest& request = {}) const;
 
        template<typename ListDataQualityRulesetEvaluationRunsRequestT = Model::ListDataQualityRulesetEvaluationRunsRequest>
        Model::ListDataQualityRulesetEvaluationRunsOutcomeCallable ListDataQualityRulesetEvaluationRunsCallable(const ListDataQualityRulesetEvaluationRunsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListDataQualityRulesetEvaluationRuns, request);
        }
 
        template<typename ListDataQualityRulesetEvaluationRunsRequestT = Model::ListDataQualityRulesetEvaluationRunsRequest>
        void ListDataQualityRulesetEvaluationRunsAsync(const ListDataQualityRulesetEvaluationRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataQualityRulesetEvaluationRunsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListDataQualityRulesetEvaluationRuns, request, handler, context);
        }
 
        virtual Model::ListDataQualityRulesetsOutcome ListDataQualityRulesets(const Model::ListDataQualityRulesetsRequest& request = {}) const;
 
        template<typename ListDataQualityRulesetsRequestT = Model::ListDataQualityRulesetsRequest>
        Model::ListDataQualityRulesetsOutcomeCallable ListDataQualityRulesetsCallable(const ListDataQualityRulesetsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListDataQualityRulesets, request);
        }
 
        template<typename ListDataQualityRulesetsRequestT = Model::ListDataQualityRulesetsRequest>
        void ListDataQualityRulesetsAsync(const ListDataQualityRulesetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataQualityRulesetsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListDataQualityRulesets, request, handler, context);
        }
 
        virtual Model::ListDataQualityStatisticAnnotationsOutcome ListDataQualityStatisticAnnotations(const Model::ListDataQualityStatisticAnnotationsRequest& request = {}) const;
 
        template<typename ListDataQualityStatisticAnnotationsRequestT = Model::ListDataQualityStatisticAnnotationsRequest>
        Model::ListDataQualityStatisticAnnotationsOutcomeCallable ListDataQualityStatisticAnnotationsCallable(const ListDataQualityStatisticAnnotationsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListDataQualityStatisticAnnotations, request);
        }
 
        template<typename ListDataQualityStatisticAnnotationsRequestT = Model::ListDataQualityStatisticAnnotationsRequest>
        void ListDataQualityStatisticAnnotationsAsync(const ListDataQualityStatisticAnnotationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataQualityStatisticAnnotationsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListDataQualityStatisticAnnotations, request, handler, context);
        }
 
        virtual Model::ListDataQualityStatisticsOutcome ListDataQualityStatistics(const Model::ListDataQualityStatisticsRequest& request = {}) const;
 
        template<typename ListDataQualityStatisticsRequestT = Model::ListDataQualityStatisticsRequest>
        Model::ListDataQualityStatisticsOutcomeCallable ListDataQualityStatisticsCallable(const ListDataQualityStatisticsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListDataQualityStatistics, request);
        }
 
        template<typename ListDataQualityStatisticsRequestT = Model::ListDataQualityStatisticsRequest>
        void ListDataQualityStatisticsAsync(const ListDataQualityStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDataQualityStatisticsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListDataQualityStatistics, request, handler, context);
        }
 
        virtual Model::ListDevEndpointsOutcome ListDevEndpoints(const Model::ListDevEndpointsRequest& request = {}) const;
 
        template<typename ListDevEndpointsRequestT = Model::ListDevEndpointsRequest>
        Model::ListDevEndpointsOutcomeCallable ListDevEndpointsCallable(const ListDevEndpointsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListDevEndpoints, request);
        }
 
        template<typename ListDevEndpointsRequestT = Model::ListDevEndpointsRequest>
        void ListDevEndpointsAsync(const ListDevEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDevEndpointsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListDevEndpoints, request, handler, context);
        }
 
        virtual Model::ListEntitiesOutcome ListEntities(const Model::ListEntitiesRequest& request = {}) const;
 
        template<typename ListEntitiesRequestT = Model::ListEntitiesRequest>
        Model::ListEntitiesOutcomeCallable ListEntitiesCallable(const ListEntitiesRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListEntities, request);
        }
 
        template<typename ListEntitiesRequestT = Model::ListEntitiesRequest>
        void ListEntitiesAsync(const ListEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEntitiesRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListEntities, 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(&GlueClient::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(&GlueClient::ListJobs, request, handler, context);
        }
 
        virtual Model::ListMLTransformsOutcome ListMLTransforms(const Model::ListMLTransformsRequest& request = {}) const;
 
        template<typename ListMLTransformsRequestT = Model::ListMLTransformsRequest>
        Model::ListMLTransformsOutcomeCallable ListMLTransformsCallable(const ListMLTransformsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListMLTransforms, request);
        }
 
        template<typename ListMLTransformsRequestT = Model::ListMLTransformsRequest>
        void ListMLTransformsAsync(const ListMLTransformsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMLTransformsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListMLTransforms, request, handler, context);
        }
 
        virtual Model::ListRegistriesOutcome ListRegistries(const Model::ListRegistriesRequest& request = {}) const;
 
        template<typename ListRegistriesRequestT = Model::ListRegistriesRequest>
        Model::ListRegistriesOutcomeCallable ListRegistriesCallable(const ListRegistriesRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListRegistries, request);
        }
 
        template<typename ListRegistriesRequestT = Model::ListRegistriesRequest>
        void ListRegistriesAsync(const ListRegistriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRegistriesRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListRegistries, request, handler, context);
        }
 
        virtual Model::ListSchemaVersionsOutcome ListSchemaVersions(const Model::ListSchemaVersionsRequest& request) const;
 
        template<typename ListSchemaVersionsRequestT = Model::ListSchemaVersionsRequest>
        Model::ListSchemaVersionsOutcomeCallable ListSchemaVersionsCallable(const ListSchemaVersionsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::ListSchemaVersions, request);
        }
 
        template<typename ListSchemaVersionsRequestT = Model::ListSchemaVersionsRequest>
        void ListSchemaVersionsAsync(const ListSchemaVersionsRequestT& request, const ListSchemaVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::ListSchemaVersions, 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(&GlueClient::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(&GlueClient::ListSchemas, request, handler, context);
        }
 
        virtual Model::ListSessionsOutcome ListSessions(const Model::ListSessionsRequest& request = {}) const;
 
        template<typename ListSessionsRequestT = Model::ListSessionsRequest>
        Model::ListSessionsOutcomeCallable ListSessionsCallable(const ListSessionsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListSessions, request);
        }
 
        template<typename ListSessionsRequestT = Model::ListSessionsRequest>
        void ListSessionsAsync(const ListSessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSessionsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListSessions, request, handler, context);
        }
 
        virtual Model::ListStatementsOutcome ListStatements(const Model::ListStatementsRequest& request) const;
 
        template<typename ListStatementsRequestT = Model::ListStatementsRequest>
        Model::ListStatementsOutcomeCallable ListStatementsCallable(const ListStatementsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::ListStatements, request);
        }
 
        template<typename ListStatementsRequestT = Model::ListStatementsRequest>
        void ListStatementsAsync(const ListStatementsRequestT& request, const ListStatementsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::ListStatements, request, handler, context);
        }
 
        virtual Model::ListTableOptimizerRunsOutcome ListTableOptimizerRuns(const Model::ListTableOptimizerRunsRequest& request) const;
 
        template<typename ListTableOptimizerRunsRequestT = Model::ListTableOptimizerRunsRequest>
        Model::ListTableOptimizerRunsOutcomeCallable ListTableOptimizerRunsCallable(const ListTableOptimizerRunsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::ListTableOptimizerRuns, request);
        }
 
        template<typename ListTableOptimizerRunsRequestT = Model::ListTableOptimizerRunsRequest>
        void ListTableOptimizerRunsAsync(const ListTableOptimizerRunsRequestT& request, const ListTableOptimizerRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::ListTableOptimizerRuns, request, handler, context);
        }
 
        virtual Model::ListTriggersOutcome ListTriggers(const Model::ListTriggersRequest& request = {}) const;
 
        template<typename ListTriggersRequestT = Model::ListTriggersRequest>
        Model::ListTriggersOutcomeCallable ListTriggersCallable(const ListTriggersRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListTriggers, request);
        }
 
        template<typename ListTriggersRequestT = Model::ListTriggersRequest>
        void ListTriggersAsync(const ListTriggersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTriggersRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListTriggers, request, handler, context);
        }
 
        virtual Model::ListUsageProfilesOutcome ListUsageProfiles(const Model::ListUsageProfilesRequest& request = {}) const;
 
        template<typename ListUsageProfilesRequestT = Model::ListUsageProfilesRequest>
        Model::ListUsageProfilesOutcomeCallable ListUsageProfilesCallable(const ListUsageProfilesRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListUsageProfiles, request);
        }
 
        template<typename ListUsageProfilesRequestT = Model::ListUsageProfilesRequest>
        void ListUsageProfilesAsync(const ListUsageProfilesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListUsageProfilesRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListUsageProfiles, request, handler, context);
        }
 
        virtual Model::ListWorkflowsOutcome ListWorkflows(const Model::ListWorkflowsRequest& request = {}) const;
 
        template<typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
        Model::ListWorkflowsOutcomeCallable ListWorkflowsCallable(const ListWorkflowsRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::ListWorkflows, request);
        }
 
        template<typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
        void ListWorkflowsAsync(const ListWorkflowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWorkflowsRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::ListWorkflows, request, handler, context);
        }
 
        virtual Model::ModifyIntegrationOutcome ModifyIntegration(const Model::ModifyIntegrationRequest& request) const;
 
        template<typename ModifyIntegrationRequestT = Model::ModifyIntegrationRequest>
        Model::ModifyIntegrationOutcomeCallable ModifyIntegrationCallable(const ModifyIntegrationRequestT& request) const
        {
            return SubmitCallable(&GlueClient::ModifyIntegration, request);
        }
 
        template<typename ModifyIntegrationRequestT = Model::ModifyIntegrationRequest>
        void ModifyIntegrationAsync(const ModifyIntegrationRequestT& request, const ModifyIntegrationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::ModifyIntegration, request, handler, context);
        }
 
        virtual Model::PutDataCatalogEncryptionSettingsOutcome PutDataCatalogEncryptionSettings(const Model::PutDataCatalogEncryptionSettingsRequest& request) const;
 
        template<typename PutDataCatalogEncryptionSettingsRequestT = Model::PutDataCatalogEncryptionSettingsRequest>
        Model::PutDataCatalogEncryptionSettingsOutcomeCallable PutDataCatalogEncryptionSettingsCallable(const PutDataCatalogEncryptionSettingsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::PutDataCatalogEncryptionSettings, request);
        }
 
        template<typename PutDataCatalogEncryptionSettingsRequestT = Model::PutDataCatalogEncryptionSettingsRequest>
        void PutDataCatalogEncryptionSettingsAsync(const PutDataCatalogEncryptionSettingsRequestT& request, const PutDataCatalogEncryptionSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::PutDataCatalogEncryptionSettings, request, handler, context);
        }
 
        virtual Model::PutDataQualityProfileAnnotationOutcome PutDataQualityProfileAnnotation(const Model::PutDataQualityProfileAnnotationRequest& request) const;
 
        template<typename PutDataQualityProfileAnnotationRequestT = Model::PutDataQualityProfileAnnotationRequest>
        Model::PutDataQualityProfileAnnotationOutcomeCallable PutDataQualityProfileAnnotationCallable(const PutDataQualityProfileAnnotationRequestT& request) const
        {
            return SubmitCallable(&GlueClient::PutDataQualityProfileAnnotation, request);
        }
 
        template<typename PutDataQualityProfileAnnotationRequestT = Model::PutDataQualityProfileAnnotationRequest>
        void PutDataQualityProfileAnnotationAsync(const PutDataQualityProfileAnnotationRequestT& request, const PutDataQualityProfileAnnotationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::PutDataQualityProfileAnnotation, request, handler, context);
        }
 
        virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const
        {
            return SubmitCallable(&GlueClient::PutResourcePolicy, request);
        }
 
        template<typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
        void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::PutResourcePolicy, request, handler, context);
        }
 
        virtual Model::PutSchemaVersionMetadataOutcome PutSchemaVersionMetadata(const Model::PutSchemaVersionMetadataRequest& request) const;
 
        template<typename PutSchemaVersionMetadataRequestT = Model::PutSchemaVersionMetadataRequest>
        Model::PutSchemaVersionMetadataOutcomeCallable PutSchemaVersionMetadataCallable(const PutSchemaVersionMetadataRequestT& request) const
        {
            return SubmitCallable(&GlueClient::PutSchemaVersionMetadata, request);
        }
 
        template<typename PutSchemaVersionMetadataRequestT = Model::PutSchemaVersionMetadataRequest>
        void PutSchemaVersionMetadataAsync(const PutSchemaVersionMetadataRequestT& request, const PutSchemaVersionMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::PutSchemaVersionMetadata, request, handler, context);
        }
 
        virtual Model::PutWorkflowRunPropertiesOutcome PutWorkflowRunProperties(const Model::PutWorkflowRunPropertiesRequest& request) const;
 
        template<typename PutWorkflowRunPropertiesRequestT = Model::PutWorkflowRunPropertiesRequest>
        Model::PutWorkflowRunPropertiesOutcomeCallable PutWorkflowRunPropertiesCallable(const PutWorkflowRunPropertiesRequestT& request) const
        {
            return SubmitCallable(&GlueClient::PutWorkflowRunProperties, request);
        }
 
        template<typename PutWorkflowRunPropertiesRequestT = Model::PutWorkflowRunPropertiesRequest>
        void PutWorkflowRunPropertiesAsync(const PutWorkflowRunPropertiesRequestT& request, const PutWorkflowRunPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::PutWorkflowRunProperties, request, handler, context);
        }
 
        virtual Model::QuerySchemaVersionMetadataOutcome QuerySchemaVersionMetadata(const Model::QuerySchemaVersionMetadataRequest& request = {}) const;
 
        template<typename QuerySchemaVersionMetadataRequestT = Model::QuerySchemaVersionMetadataRequest>
        Model::QuerySchemaVersionMetadataOutcomeCallable QuerySchemaVersionMetadataCallable(const QuerySchemaVersionMetadataRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::QuerySchemaVersionMetadata, request);
        }
 
        template<typename QuerySchemaVersionMetadataRequestT = Model::QuerySchemaVersionMetadataRequest>
        void QuerySchemaVersionMetadataAsync(const QuerySchemaVersionMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const QuerySchemaVersionMetadataRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::QuerySchemaVersionMetadata, request, handler, context);
        }
 
        virtual Model::RegisterSchemaVersionOutcome RegisterSchemaVersion(const Model::RegisterSchemaVersionRequest& request) const;
 
        template<typename RegisterSchemaVersionRequestT = Model::RegisterSchemaVersionRequest>
        Model::RegisterSchemaVersionOutcomeCallable RegisterSchemaVersionCallable(const RegisterSchemaVersionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::RegisterSchemaVersion, request);
        }
 
        template<typename RegisterSchemaVersionRequestT = Model::RegisterSchemaVersionRequest>
        void RegisterSchemaVersionAsync(const RegisterSchemaVersionRequestT& request, const RegisterSchemaVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::RegisterSchemaVersion, request, handler, context);
        }
 
        virtual Model::RemoveSchemaVersionMetadataOutcome RemoveSchemaVersionMetadata(const Model::RemoveSchemaVersionMetadataRequest& request) const;
 
        template<typename RemoveSchemaVersionMetadataRequestT = Model::RemoveSchemaVersionMetadataRequest>
        Model::RemoveSchemaVersionMetadataOutcomeCallable RemoveSchemaVersionMetadataCallable(const RemoveSchemaVersionMetadataRequestT& request) const
        {
            return SubmitCallable(&GlueClient::RemoveSchemaVersionMetadata, request);
        }
 
        template<typename RemoveSchemaVersionMetadataRequestT = Model::RemoveSchemaVersionMetadataRequest>
        void RemoveSchemaVersionMetadataAsync(const RemoveSchemaVersionMetadataRequestT& request, const RemoveSchemaVersionMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::RemoveSchemaVersionMetadata, request, handler, context);
        }
 
        virtual Model::ResetJobBookmarkOutcome ResetJobBookmark(const Model::ResetJobBookmarkRequest& request) const;
 
        template<typename ResetJobBookmarkRequestT = Model::ResetJobBookmarkRequest>
        Model::ResetJobBookmarkOutcomeCallable ResetJobBookmarkCallable(const ResetJobBookmarkRequestT& request) const
        {
            return SubmitCallable(&GlueClient::ResetJobBookmark, request);
        }
 
        template<typename ResetJobBookmarkRequestT = Model::ResetJobBookmarkRequest>
        void ResetJobBookmarkAsync(const ResetJobBookmarkRequestT& request, const ResetJobBookmarkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::ResetJobBookmark, request, handler, context);
        }
 
        virtual Model::ResumeWorkflowRunOutcome ResumeWorkflowRun(const Model::ResumeWorkflowRunRequest& request) const;
 
        template<typename ResumeWorkflowRunRequestT = Model::ResumeWorkflowRunRequest>
        Model::ResumeWorkflowRunOutcomeCallable ResumeWorkflowRunCallable(const ResumeWorkflowRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::ResumeWorkflowRun, request);
        }
 
        template<typename ResumeWorkflowRunRequestT = Model::ResumeWorkflowRunRequest>
        void ResumeWorkflowRunAsync(const ResumeWorkflowRunRequestT& request, const ResumeWorkflowRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::ResumeWorkflowRun, request, handler, context);
        }
 
        virtual Model::RunStatementOutcome RunStatement(const Model::RunStatementRequest& request) const;
 
        template<typename RunStatementRequestT = Model::RunStatementRequest>
        Model::RunStatementOutcomeCallable RunStatementCallable(const RunStatementRequestT& request) const
        {
            return SubmitCallable(&GlueClient::RunStatement, request);
        }
 
        template<typename RunStatementRequestT = Model::RunStatementRequest>
        void RunStatementAsync(const RunStatementRequestT& request, const RunStatementResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::RunStatement, request, handler, context);
        }
 
        virtual Model::SearchTablesOutcome SearchTables(const Model::SearchTablesRequest& request = {}) const;
 
        template<typename SearchTablesRequestT = Model::SearchTablesRequest>
        Model::SearchTablesOutcomeCallable SearchTablesCallable(const SearchTablesRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::SearchTables, request);
        }
 
        template<typename SearchTablesRequestT = Model::SearchTablesRequest>
        void SearchTablesAsync(const SearchTablesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SearchTablesRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::SearchTables, request, handler, context);
        }
 
        virtual Model::StartBlueprintRunOutcome StartBlueprintRun(const Model::StartBlueprintRunRequest& request) const;
 
        template<typename StartBlueprintRunRequestT = Model::StartBlueprintRunRequest>
        Model::StartBlueprintRunOutcomeCallable StartBlueprintRunCallable(const StartBlueprintRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartBlueprintRun, request);
        }
 
        template<typename StartBlueprintRunRequestT = Model::StartBlueprintRunRequest>
        void StartBlueprintRunAsync(const StartBlueprintRunRequestT& request, const StartBlueprintRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartBlueprintRun, request, handler, context);
        }
 
        virtual Model::StartColumnStatisticsTaskRunOutcome StartColumnStatisticsTaskRun(const Model::StartColumnStatisticsTaskRunRequest& request) const;
 
        template<typename StartColumnStatisticsTaskRunRequestT = Model::StartColumnStatisticsTaskRunRequest>
        Model::StartColumnStatisticsTaskRunOutcomeCallable StartColumnStatisticsTaskRunCallable(const StartColumnStatisticsTaskRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartColumnStatisticsTaskRun, request);
        }
 
        template<typename StartColumnStatisticsTaskRunRequestT = Model::StartColumnStatisticsTaskRunRequest>
        void StartColumnStatisticsTaskRunAsync(const StartColumnStatisticsTaskRunRequestT& request, const StartColumnStatisticsTaskRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartColumnStatisticsTaskRun, request, handler, context);
        }
 
        virtual Model::StartColumnStatisticsTaskRunScheduleOutcome StartColumnStatisticsTaskRunSchedule(const Model::StartColumnStatisticsTaskRunScheduleRequest& request) const;
 
        template<typename StartColumnStatisticsTaskRunScheduleRequestT = Model::StartColumnStatisticsTaskRunScheduleRequest>
        Model::StartColumnStatisticsTaskRunScheduleOutcomeCallable StartColumnStatisticsTaskRunScheduleCallable(const StartColumnStatisticsTaskRunScheduleRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartColumnStatisticsTaskRunSchedule, request);
        }
 
        template<typename StartColumnStatisticsTaskRunScheduleRequestT = Model::StartColumnStatisticsTaskRunScheduleRequest>
        void StartColumnStatisticsTaskRunScheduleAsync(const StartColumnStatisticsTaskRunScheduleRequestT& request, const StartColumnStatisticsTaskRunScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartColumnStatisticsTaskRunSchedule, request, handler, context);
        }
 
        virtual Model::StartCrawlerOutcome StartCrawler(const Model::StartCrawlerRequest& request) const;
 
        template<typename StartCrawlerRequestT = Model::StartCrawlerRequest>
        Model::StartCrawlerOutcomeCallable StartCrawlerCallable(const StartCrawlerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartCrawler, request);
        }
 
        template<typename StartCrawlerRequestT = Model::StartCrawlerRequest>
        void StartCrawlerAsync(const StartCrawlerRequestT& request, const StartCrawlerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartCrawler, request, handler, context);
        }
 
        virtual Model::StartCrawlerScheduleOutcome StartCrawlerSchedule(const Model::StartCrawlerScheduleRequest& request) const;
 
        template<typename StartCrawlerScheduleRequestT = Model::StartCrawlerScheduleRequest>
        Model::StartCrawlerScheduleOutcomeCallable StartCrawlerScheduleCallable(const StartCrawlerScheduleRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartCrawlerSchedule, request);
        }
 
        template<typename StartCrawlerScheduleRequestT = Model::StartCrawlerScheduleRequest>
        void StartCrawlerScheduleAsync(const StartCrawlerScheduleRequestT& request, const StartCrawlerScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartCrawlerSchedule, request, handler, context);
        }
 
        virtual Model::StartDataQualityRuleRecommendationRunOutcome StartDataQualityRuleRecommendationRun(const Model::StartDataQualityRuleRecommendationRunRequest& request) const;
 
        template<typename StartDataQualityRuleRecommendationRunRequestT = Model::StartDataQualityRuleRecommendationRunRequest>
        Model::StartDataQualityRuleRecommendationRunOutcomeCallable StartDataQualityRuleRecommendationRunCallable(const StartDataQualityRuleRecommendationRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartDataQualityRuleRecommendationRun, request);
        }
 
        template<typename StartDataQualityRuleRecommendationRunRequestT = Model::StartDataQualityRuleRecommendationRunRequest>
        void StartDataQualityRuleRecommendationRunAsync(const StartDataQualityRuleRecommendationRunRequestT& request, const StartDataQualityRuleRecommendationRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartDataQualityRuleRecommendationRun, request, handler, context);
        }
 
        virtual Model::StartDataQualityRulesetEvaluationRunOutcome StartDataQualityRulesetEvaluationRun(const Model::StartDataQualityRulesetEvaluationRunRequest& request) const;
 
        template<typename StartDataQualityRulesetEvaluationRunRequestT = Model::StartDataQualityRulesetEvaluationRunRequest>
        Model::StartDataQualityRulesetEvaluationRunOutcomeCallable StartDataQualityRulesetEvaluationRunCallable(const StartDataQualityRulesetEvaluationRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartDataQualityRulesetEvaluationRun, request);
        }
 
        template<typename StartDataQualityRulesetEvaluationRunRequestT = Model::StartDataQualityRulesetEvaluationRunRequest>
        void StartDataQualityRulesetEvaluationRunAsync(const StartDataQualityRulesetEvaluationRunRequestT& request, const StartDataQualityRulesetEvaluationRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartDataQualityRulesetEvaluationRun, request, handler, context);
        }
 
        virtual Model::StartExportLabelsTaskRunOutcome StartExportLabelsTaskRun(const Model::StartExportLabelsTaskRunRequest& request) const;
 
        template<typename StartExportLabelsTaskRunRequestT = Model::StartExportLabelsTaskRunRequest>
        Model::StartExportLabelsTaskRunOutcomeCallable StartExportLabelsTaskRunCallable(const StartExportLabelsTaskRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartExportLabelsTaskRun, request);
        }
 
        template<typename StartExportLabelsTaskRunRequestT = Model::StartExportLabelsTaskRunRequest>
        void StartExportLabelsTaskRunAsync(const StartExportLabelsTaskRunRequestT& request, const StartExportLabelsTaskRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartExportLabelsTaskRun, request, handler, context);
        }
 
        virtual Model::StartImportLabelsTaskRunOutcome StartImportLabelsTaskRun(const Model::StartImportLabelsTaskRunRequest& request) const;
 
        template<typename StartImportLabelsTaskRunRequestT = Model::StartImportLabelsTaskRunRequest>
        Model::StartImportLabelsTaskRunOutcomeCallable StartImportLabelsTaskRunCallable(const StartImportLabelsTaskRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartImportLabelsTaskRun, request);
        }
 
        template<typename StartImportLabelsTaskRunRequestT = Model::StartImportLabelsTaskRunRequest>
        void StartImportLabelsTaskRunAsync(const StartImportLabelsTaskRunRequestT& request, const StartImportLabelsTaskRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartImportLabelsTaskRun, 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(&GlueClient::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(&GlueClient::StartJobRun, request, handler, context);
        }
 
        virtual Model::StartMLEvaluationTaskRunOutcome StartMLEvaluationTaskRun(const Model::StartMLEvaluationTaskRunRequest& request) const;
 
        template<typename StartMLEvaluationTaskRunRequestT = Model::StartMLEvaluationTaskRunRequest>
        Model::StartMLEvaluationTaskRunOutcomeCallable StartMLEvaluationTaskRunCallable(const StartMLEvaluationTaskRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartMLEvaluationTaskRun, request);
        }
 
        template<typename StartMLEvaluationTaskRunRequestT = Model::StartMLEvaluationTaskRunRequest>
        void StartMLEvaluationTaskRunAsync(const StartMLEvaluationTaskRunRequestT& request, const StartMLEvaluationTaskRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartMLEvaluationTaskRun, request, handler, context);
        }
 
        virtual Model::StartMLLabelingSetGenerationTaskRunOutcome StartMLLabelingSetGenerationTaskRun(const Model::StartMLLabelingSetGenerationTaskRunRequest& request) const;
 
        template<typename StartMLLabelingSetGenerationTaskRunRequestT = Model::StartMLLabelingSetGenerationTaskRunRequest>
        Model::StartMLLabelingSetGenerationTaskRunOutcomeCallable StartMLLabelingSetGenerationTaskRunCallable(const StartMLLabelingSetGenerationTaskRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartMLLabelingSetGenerationTaskRun, request);
        }
 
        template<typename StartMLLabelingSetGenerationTaskRunRequestT = Model::StartMLLabelingSetGenerationTaskRunRequest>
        void StartMLLabelingSetGenerationTaskRunAsync(const StartMLLabelingSetGenerationTaskRunRequestT& request, const StartMLLabelingSetGenerationTaskRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartMLLabelingSetGenerationTaskRun, request, handler, context);
        }
 
        virtual Model::StartTriggerOutcome StartTrigger(const Model::StartTriggerRequest& request) const;
 
        template<typename StartTriggerRequestT = Model::StartTriggerRequest>
        Model::StartTriggerOutcomeCallable StartTriggerCallable(const StartTriggerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartTrigger, request);
        }
 
        template<typename StartTriggerRequestT = Model::StartTriggerRequest>
        void StartTriggerAsync(const StartTriggerRequestT& request, const StartTriggerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartTrigger, request, handler, context);
        }
 
        virtual Model::StartWorkflowRunOutcome StartWorkflowRun(const Model::StartWorkflowRunRequest& request) const;
 
        template<typename StartWorkflowRunRequestT = Model::StartWorkflowRunRequest>
        Model::StartWorkflowRunOutcomeCallable StartWorkflowRunCallable(const StartWorkflowRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StartWorkflowRun, request);
        }
 
        template<typename StartWorkflowRunRequestT = Model::StartWorkflowRunRequest>
        void StartWorkflowRunAsync(const StartWorkflowRunRequestT& request, const StartWorkflowRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StartWorkflowRun, request, handler, context);
        }
 
        virtual Model::StopColumnStatisticsTaskRunOutcome StopColumnStatisticsTaskRun(const Model::StopColumnStatisticsTaskRunRequest& request) const;
 
        template<typename StopColumnStatisticsTaskRunRequestT = Model::StopColumnStatisticsTaskRunRequest>
        Model::StopColumnStatisticsTaskRunOutcomeCallable StopColumnStatisticsTaskRunCallable(const StopColumnStatisticsTaskRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StopColumnStatisticsTaskRun, request);
        }
 
        template<typename StopColumnStatisticsTaskRunRequestT = Model::StopColumnStatisticsTaskRunRequest>
        void StopColumnStatisticsTaskRunAsync(const StopColumnStatisticsTaskRunRequestT& request, const StopColumnStatisticsTaskRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StopColumnStatisticsTaskRun, request, handler, context);
        }
 
        virtual Model::StopColumnStatisticsTaskRunScheduleOutcome StopColumnStatisticsTaskRunSchedule(const Model::StopColumnStatisticsTaskRunScheduleRequest& request) const;
 
        template<typename StopColumnStatisticsTaskRunScheduleRequestT = Model::StopColumnStatisticsTaskRunScheduleRequest>
        Model::StopColumnStatisticsTaskRunScheduleOutcomeCallable StopColumnStatisticsTaskRunScheduleCallable(const StopColumnStatisticsTaskRunScheduleRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StopColumnStatisticsTaskRunSchedule, request);
        }
 
        template<typename StopColumnStatisticsTaskRunScheduleRequestT = Model::StopColumnStatisticsTaskRunScheduleRequest>
        void StopColumnStatisticsTaskRunScheduleAsync(const StopColumnStatisticsTaskRunScheduleRequestT& request, const StopColumnStatisticsTaskRunScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StopColumnStatisticsTaskRunSchedule, request, handler, context);
        }
 
        virtual Model::StopCrawlerOutcome StopCrawler(const Model::StopCrawlerRequest& request) const;
 
        template<typename StopCrawlerRequestT = Model::StopCrawlerRequest>
        Model::StopCrawlerOutcomeCallable StopCrawlerCallable(const StopCrawlerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StopCrawler, request);
        }
 
        template<typename StopCrawlerRequestT = Model::StopCrawlerRequest>
        void StopCrawlerAsync(const StopCrawlerRequestT& request, const StopCrawlerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StopCrawler, request, handler, context);
        }
 
        virtual Model::StopCrawlerScheduleOutcome StopCrawlerSchedule(const Model::StopCrawlerScheduleRequest& request) const;
 
        template<typename StopCrawlerScheduleRequestT = Model::StopCrawlerScheduleRequest>
        Model::StopCrawlerScheduleOutcomeCallable StopCrawlerScheduleCallable(const StopCrawlerScheduleRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StopCrawlerSchedule, request);
        }
 
        template<typename StopCrawlerScheduleRequestT = Model::StopCrawlerScheduleRequest>
        void StopCrawlerScheduleAsync(const StopCrawlerScheduleRequestT& request, const StopCrawlerScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StopCrawlerSchedule, request, handler, context);
        }
 
        virtual Model::StopSessionOutcome StopSession(const Model::StopSessionRequest& request) const;
 
        template<typename StopSessionRequestT = Model::StopSessionRequest>
        Model::StopSessionOutcomeCallable StopSessionCallable(const StopSessionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StopSession, request);
        }
 
        template<typename StopSessionRequestT = Model::StopSessionRequest>
        void StopSessionAsync(const StopSessionRequestT& request, const StopSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StopSession, request, handler, context);
        }
 
        virtual Model::StopTriggerOutcome StopTrigger(const Model::StopTriggerRequest& request) const;
 
        template<typename StopTriggerRequestT = Model::StopTriggerRequest>
        Model::StopTriggerOutcomeCallable StopTriggerCallable(const StopTriggerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StopTrigger, request);
        }
 
        template<typename StopTriggerRequestT = Model::StopTriggerRequest>
        void StopTriggerAsync(const StopTriggerRequestT& request, const StopTriggerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StopTrigger, request, handler, context);
        }
 
        virtual Model::StopWorkflowRunOutcome StopWorkflowRun(const Model::StopWorkflowRunRequest& request) const;
 
        template<typename StopWorkflowRunRequestT = Model::StopWorkflowRunRequest>
        Model::StopWorkflowRunOutcomeCallable StopWorkflowRunCallable(const StopWorkflowRunRequestT& request) const
        {
            return SubmitCallable(&GlueClient::StopWorkflowRun, request);
        }
 
        template<typename StopWorkflowRunRequestT = Model::StopWorkflowRunRequest>
        void StopWorkflowRunAsync(const StopWorkflowRunRequestT& request, const StopWorkflowRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::StopWorkflowRun, 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(&GlueClient::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(&GlueClient::TagResource, request, handler, context);
        }
 
        virtual Model::TestConnectionOutcome TestConnection(const Model::TestConnectionRequest& request = {}) const;
 
        template<typename TestConnectionRequestT = Model::TestConnectionRequest>
        Model::TestConnectionOutcomeCallable TestConnectionCallable(const TestConnectionRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::TestConnection, request);
        }
 
        template<typename TestConnectionRequestT = Model::TestConnectionRequest>
        void TestConnectionAsync(const TestConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const TestConnectionRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::TestConnection, 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(&GlueClient::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(&GlueClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateBlueprintOutcome UpdateBlueprint(const Model::UpdateBlueprintRequest& request) const;
 
        template<typename UpdateBlueprintRequestT = Model::UpdateBlueprintRequest>
        Model::UpdateBlueprintOutcomeCallable UpdateBlueprintCallable(const UpdateBlueprintRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateBlueprint, request);
        }
 
        template<typename UpdateBlueprintRequestT = Model::UpdateBlueprintRequest>
        void UpdateBlueprintAsync(const UpdateBlueprintRequestT& request, const UpdateBlueprintResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateBlueprint, request, handler, context);
        }
 
        virtual Model::UpdateCatalogOutcome UpdateCatalog(const Model::UpdateCatalogRequest& request) const;
 
        template<typename UpdateCatalogRequestT = Model::UpdateCatalogRequest>
        Model::UpdateCatalogOutcomeCallable UpdateCatalogCallable(const UpdateCatalogRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateCatalog, request);
        }
 
        template<typename UpdateCatalogRequestT = Model::UpdateCatalogRequest>
        void UpdateCatalogAsync(const UpdateCatalogRequestT& request, const UpdateCatalogResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateCatalog, request, handler, context);
        }
 
        virtual Model::UpdateClassifierOutcome UpdateClassifier(const Model::UpdateClassifierRequest& request = {}) const;
 
        template<typename UpdateClassifierRequestT = Model::UpdateClassifierRequest>
        Model::UpdateClassifierOutcomeCallable UpdateClassifierCallable(const UpdateClassifierRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::UpdateClassifier, request);
        }
 
        template<typename UpdateClassifierRequestT = Model::UpdateClassifierRequest>
        void UpdateClassifierAsync(const UpdateClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateClassifierRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::UpdateClassifier, request, handler, context);
        }
 
        virtual Model::UpdateColumnStatisticsForPartitionOutcome UpdateColumnStatisticsForPartition(const Model::UpdateColumnStatisticsForPartitionRequest& request) const;
 
        template<typename UpdateColumnStatisticsForPartitionRequestT = Model::UpdateColumnStatisticsForPartitionRequest>
        Model::UpdateColumnStatisticsForPartitionOutcomeCallable UpdateColumnStatisticsForPartitionCallable(const UpdateColumnStatisticsForPartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateColumnStatisticsForPartition, request);
        }
 
        template<typename UpdateColumnStatisticsForPartitionRequestT = Model::UpdateColumnStatisticsForPartitionRequest>
        void UpdateColumnStatisticsForPartitionAsync(const UpdateColumnStatisticsForPartitionRequestT& request, const UpdateColumnStatisticsForPartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateColumnStatisticsForPartition, request, handler, context);
        }
 
        virtual Model::UpdateColumnStatisticsForTableOutcome UpdateColumnStatisticsForTable(const Model::UpdateColumnStatisticsForTableRequest& request) const;
 
        template<typename UpdateColumnStatisticsForTableRequestT = Model::UpdateColumnStatisticsForTableRequest>
        Model::UpdateColumnStatisticsForTableOutcomeCallable UpdateColumnStatisticsForTableCallable(const UpdateColumnStatisticsForTableRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateColumnStatisticsForTable, request);
        }
 
        template<typename UpdateColumnStatisticsForTableRequestT = Model::UpdateColumnStatisticsForTableRequest>
        void UpdateColumnStatisticsForTableAsync(const UpdateColumnStatisticsForTableRequestT& request, const UpdateColumnStatisticsForTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateColumnStatisticsForTable, request, handler, context);
        }
 
        virtual Model::UpdateColumnStatisticsTaskSettingsOutcome UpdateColumnStatisticsTaskSettings(const Model::UpdateColumnStatisticsTaskSettingsRequest& request) const;
 
        template<typename UpdateColumnStatisticsTaskSettingsRequestT = Model::UpdateColumnStatisticsTaskSettingsRequest>
        Model::UpdateColumnStatisticsTaskSettingsOutcomeCallable UpdateColumnStatisticsTaskSettingsCallable(const UpdateColumnStatisticsTaskSettingsRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateColumnStatisticsTaskSettings, request);
        }
 
        template<typename UpdateColumnStatisticsTaskSettingsRequestT = Model::UpdateColumnStatisticsTaskSettingsRequest>
        void UpdateColumnStatisticsTaskSettingsAsync(const UpdateColumnStatisticsTaskSettingsRequestT& request, const UpdateColumnStatisticsTaskSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateColumnStatisticsTaskSettings, request, handler, context);
        }
 
        virtual Model::UpdateConnectionOutcome UpdateConnection(const Model::UpdateConnectionRequest& request) const;
 
        template<typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
        Model::UpdateConnectionOutcomeCallable UpdateConnectionCallable(const UpdateConnectionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateConnection, request);
        }
 
        template<typename UpdateConnectionRequestT = Model::UpdateConnectionRequest>
        void UpdateConnectionAsync(const UpdateConnectionRequestT& request, const UpdateConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateConnection, request, handler, context);
        }
 
        virtual Model::UpdateCrawlerOutcome UpdateCrawler(const Model::UpdateCrawlerRequest& request) const;
 
        template<typename UpdateCrawlerRequestT = Model::UpdateCrawlerRequest>
        Model::UpdateCrawlerOutcomeCallable UpdateCrawlerCallable(const UpdateCrawlerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateCrawler, request);
        }
 
        template<typename UpdateCrawlerRequestT = Model::UpdateCrawlerRequest>
        void UpdateCrawlerAsync(const UpdateCrawlerRequestT& request, const UpdateCrawlerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateCrawler, request, handler, context);
        }
 
        virtual Model::UpdateCrawlerScheduleOutcome UpdateCrawlerSchedule(const Model::UpdateCrawlerScheduleRequest& request) const;
 
        template<typename UpdateCrawlerScheduleRequestT = Model::UpdateCrawlerScheduleRequest>
        Model::UpdateCrawlerScheduleOutcomeCallable UpdateCrawlerScheduleCallable(const UpdateCrawlerScheduleRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateCrawlerSchedule, request);
        }
 
        template<typename UpdateCrawlerScheduleRequestT = Model::UpdateCrawlerScheduleRequest>
        void UpdateCrawlerScheduleAsync(const UpdateCrawlerScheduleRequestT& request, const UpdateCrawlerScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateCrawlerSchedule, request, handler, context);
        }
 
        virtual Model::UpdateDataQualityRulesetOutcome UpdateDataQualityRuleset(const Model::UpdateDataQualityRulesetRequest& request) const;
 
        template<typename UpdateDataQualityRulesetRequestT = Model::UpdateDataQualityRulesetRequest>
        Model::UpdateDataQualityRulesetOutcomeCallable UpdateDataQualityRulesetCallable(const UpdateDataQualityRulesetRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateDataQualityRuleset, request);
        }
 
        template<typename UpdateDataQualityRulesetRequestT = Model::UpdateDataQualityRulesetRequest>
        void UpdateDataQualityRulesetAsync(const UpdateDataQualityRulesetRequestT& request, const UpdateDataQualityRulesetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateDataQualityRuleset, request, handler, context);
        }
 
        virtual Model::UpdateDatabaseOutcome UpdateDatabase(const Model::UpdateDatabaseRequest& request) const;
 
        template<typename UpdateDatabaseRequestT = Model::UpdateDatabaseRequest>
        Model::UpdateDatabaseOutcomeCallable UpdateDatabaseCallable(const UpdateDatabaseRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateDatabase, request);
        }
 
        template<typename UpdateDatabaseRequestT = Model::UpdateDatabaseRequest>
        void UpdateDatabaseAsync(const UpdateDatabaseRequestT& request, const UpdateDatabaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateDatabase, request, handler, context);
        }
 
        virtual Model::UpdateDevEndpointOutcome UpdateDevEndpoint(const Model::UpdateDevEndpointRequest& request) const;
 
        template<typename UpdateDevEndpointRequestT = Model::UpdateDevEndpointRequest>
        Model::UpdateDevEndpointOutcomeCallable UpdateDevEndpointCallable(const UpdateDevEndpointRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateDevEndpoint, request);
        }
 
        template<typename UpdateDevEndpointRequestT = Model::UpdateDevEndpointRequest>
        void UpdateDevEndpointAsync(const UpdateDevEndpointRequestT& request, const UpdateDevEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateDevEndpoint, request, handler, context);
        }
 
        virtual Model::UpdateGlueIdentityCenterConfigurationOutcome UpdateGlueIdentityCenterConfiguration(const Model::UpdateGlueIdentityCenterConfigurationRequest& request = {}) const;
 
        template<typename UpdateGlueIdentityCenterConfigurationRequestT = Model::UpdateGlueIdentityCenterConfigurationRequest>
        Model::UpdateGlueIdentityCenterConfigurationOutcomeCallable UpdateGlueIdentityCenterConfigurationCallable(const UpdateGlueIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::UpdateGlueIdentityCenterConfiguration, request);
        }
 
        template<typename UpdateGlueIdentityCenterConfigurationRequestT = Model::UpdateGlueIdentityCenterConfigurationRequest>
        void UpdateGlueIdentityCenterConfigurationAsync(const UpdateGlueIdentityCenterConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateGlueIdentityCenterConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::UpdateGlueIdentityCenterConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateIntegrationResourcePropertyOutcome UpdateIntegrationResourceProperty(const Model::UpdateIntegrationResourcePropertyRequest& request) const;
 
        template<typename UpdateIntegrationResourcePropertyRequestT = Model::UpdateIntegrationResourcePropertyRequest>
        Model::UpdateIntegrationResourcePropertyOutcomeCallable UpdateIntegrationResourcePropertyCallable(const UpdateIntegrationResourcePropertyRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateIntegrationResourceProperty, request);
        }
 
        template<typename UpdateIntegrationResourcePropertyRequestT = Model::UpdateIntegrationResourcePropertyRequest>
        void UpdateIntegrationResourcePropertyAsync(const UpdateIntegrationResourcePropertyRequestT& request, const UpdateIntegrationResourcePropertyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateIntegrationResourceProperty, request, handler, context);
        }
 
        virtual Model::UpdateIntegrationTablePropertiesOutcome UpdateIntegrationTableProperties(const Model::UpdateIntegrationTablePropertiesRequest& request) const;
 
        template<typename UpdateIntegrationTablePropertiesRequestT = Model::UpdateIntegrationTablePropertiesRequest>
        Model::UpdateIntegrationTablePropertiesOutcomeCallable UpdateIntegrationTablePropertiesCallable(const UpdateIntegrationTablePropertiesRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateIntegrationTableProperties, request);
        }
 
        template<typename UpdateIntegrationTablePropertiesRequestT = Model::UpdateIntegrationTablePropertiesRequest>
        void UpdateIntegrationTablePropertiesAsync(const UpdateIntegrationTablePropertiesRequestT& request, const UpdateIntegrationTablePropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateIntegrationTableProperties, request, handler, context);
        }
 
        virtual Model::UpdateJobOutcome UpdateJob(const Model::UpdateJobRequest& request) const;
 
        template<typename UpdateJobRequestT = Model::UpdateJobRequest>
        Model::UpdateJobOutcomeCallable UpdateJobCallable(const UpdateJobRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateJob, request);
        }
 
        template<typename UpdateJobRequestT = Model::UpdateJobRequest>
        void UpdateJobAsync(const UpdateJobRequestT& request, const UpdateJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateJob, request, handler, context);
        }
 
        virtual Model::UpdateJobFromSourceControlOutcome UpdateJobFromSourceControl(const Model::UpdateJobFromSourceControlRequest& request = {}) const;
 
        template<typename UpdateJobFromSourceControlRequestT = Model::UpdateJobFromSourceControlRequest>
        Model::UpdateJobFromSourceControlOutcomeCallable UpdateJobFromSourceControlCallable(const UpdateJobFromSourceControlRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::UpdateJobFromSourceControl, request);
        }
 
        template<typename UpdateJobFromSourceControlRequestT = Model::UpdateJobFromSourceControlRequest>
        void UpdateJobFromSourceControlAsync(const UpdateJobFromSourceControlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateJobFromSourceControlRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::UpdateJobFromSourceControl, request, handler, context);
        }
 
        virtual Model::UpdateMLTransformOutcome UpdateMLTransform(const Model::UpdateMLTransformRequest& request) const;
 
        template<typename UpdateMLTransformRequestT = Model::UpdateMLTransformRequest>
        Model::UpdateMLTransformOutcomeCallable UpdateMLTransformCallable(const UpdateMLTransformRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateMLTransform, request);
        }
 
        template<typename UpdateMLTransformRequestT = Model::UpdateMLTransformRequest>
        void UpdateMLTransformAsync(const UpdateMLTransformRequestT& request, const UpdateMLTransformResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateMLTransform, request, handler, context);
        }
 
        virtual Model::UpdatePartitionOutcome UpdatePartition(const Model::UpdatePartitionRequest& request) const;
 
        template<typename UpdatePartitionRequestT = Model::UpdatePartitionRequest>
        Model::UpdatePartitionOutcomeCallable UpdatePartitionCallable(const UpdatePartitionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdatePartition, request);
        }
 
        template<typename UpdatePartitionRequestT = Model::UpdatePartitionRequest>
        void UpdatePartitionAsync(const UpdatePartitionRequestT& request, const UpdatePartitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdatePartition, request, handler, context);
        }
 
        virtual Model::UpdateRegistryOutcome UpdateRegistry(const Model::UpdateRegistryRequest& request) const;
 
        template<typename UpdateRegistryRequestT = Model::UpdateRegistryRequest>
        Model::UpdateRegistryOutcomeCallable UpdateRegistryCallable(const UpdateRegistryRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateRegistry, request);
        }
 
        template<typename UpdateRegistryRequestT = Model::UpdateRegistryRequest>
        void UpdateRegistryAsync(const UpdateRegistryRequestT& request, const UpdateRegistryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateRegistry, request, handler, context);
        }
 
        virtual Model::UpdateSchemaOutcome UpdateSchema(const Model::UpdateSchemaRequest& request) const;
 
        template<typename UpdateSchemaRequestT = Model::UpdateSchemaRequest>
        Model::UpdateSchemaOutcomeCallable UpdateSchemaCallable(const UpdateSchemaRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateSchema, request);
        }
 
        template<typename UpdateSchemaRequestT = Model::UpdateSchemaRequest>
        void UpdateSchemaAsync(const UpdateSchemaRequestT& request, const UpdateSchemaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateSchema, request, handler, context);
        }
 
        virtual Model::UpdateSourceControlFromJobOutcome UpdateSourceControlFromJob(const Model::UpdateSourceControlFromJobRequest& request = {}) const;
 
        template<typename UpdateSourceControlFromJobRequestT = Model::UpdateSourceControlFromJobRequest>
        Model::UpdateSourceControlFromJobOutcomeCallable UpdateSourceControlFromJobCallable(const UpdateSourceControlFromJobRequestT& request = {}) const
        {
            return SubmitCallable(&GlueClient::UpdateSourceControlFromJob, request);
        }
 
        template<typename UpdateSourceControlFromJobRequestT = Model::UpdateSourceControlFromJobRequest>
        void UpdateSourceControlFromJobAsync(const UpdateSourceControlFromJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateSourceControlFromJobRequestT& request = {}) const
        {
            return SubmitAsync(&GlueClient::UpdateSourceControlFromJob, request, handler, context);
        }
 
        virtual Model::UpdateTableOutcome UpdateTable(const Model::UpdateTableRequest& request) const;
 
        template<typename UpdateTableRequestT = Model::UpdateTableRequest>
        Model::UpdateTableOutcomeCallable UpdateTableCallable(const UpdateTableRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateTable, request);
        }
 
        template<typename UpdateTableRequestT = Model::UpdateTableRequest>
        void UpdateTableAsync(const UpdateTableRequestT& request, const UpdateTableResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateTable, request, handler, context);
        }
 
        virtual Model::UpdateTableOptimizerOutcome UpdateTableOptimizer(const Model::UpdateTableOptimizerRequest& request) const;
 
        template<typename UpdateTableOptimizerRequestT = Model::UpdateTableOptimizerRequest>
        Model::UpdateTableOptimizerOutcomeCallable UpdateTableOptimizerCallable(const UpdateTableOptimizerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateTableOptimizer, request);
        }
 
        template<typename UpdateTableOptimizerRequestT = Model::UpdateTableOptimizerRequest>
        void UpdateTableOptimizerAsync(const UpdateTableOptimizerRequestT& request, const UpdateTableOptimizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateTableOptimizer, request, handler, context);
        }
 
        virtual Model::UpdateTriggerOutcome UpdateTrigger(const Model::UpdateTriggerRequest& request) const;
 
        template<typename UpdateTriggerRequestT = Model::UpdateTriggerRequest>
        Model::UpdateTriggerOutcomeCallable UpdateTriggerCallable(const UpdateTriggerRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateTrigger, request);
        }
 
        template<typename UpdateTriggerRequestT = Model::UpdateTriggerRequest>
        void UpdateTriggerAsync(const UpdateTriggerRequestT& request, const UpdateTriggerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateTrigger, request, handler, context);
        }
 
        virtual Model::UpdateUsageProfileOutcome UpdateUsageProfile(const Model::UpdateUsageProfileRequest& request) const;
 
        template<typename UpdateUsageProfileRequestT = Model::UpdateUsageProfileRequest>
        Model::UpdateUsageProfileOutcomeCallable UpdateUsageProfileCallable(const UpdateUsageProfileRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateUsageProfile, request);
        }
 
        template<typename UpdateUsageProfileRequestT = Model::UpdateUsageProfileRequest>
        void UpdateUsageProfileAsync(const UpdateUsageProfileRequestT& request, const UpdateUsageProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateUsageProfile, request, handler, context);
        }
 
        virtual Model::UpdateUserDefinedFunctionOutcome UpdateUserDefinedFunction(const Model::UpdateUserDefinedFunctionRequest& request) const;
 
        template<typename UpdateUserDefinedFunctionRequestT = Model::UpdateUserDefinedFunctionRequest>
        Model::UpdateUserDefinedFunctionOutcomeCallable UpdateUserDefinedFunctionCallable(const UpdateUserDefinedFunctionRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateUserDefinedFunction, request);
        }
 
        template<typename UpdateUserDefinedFunctionRequestT = Model::UpdateUserDefinedFunctionRequest>
        void UpdateUserDefinedFunctionAsync(const UpdateUserDefinedFunctionRequestT& request, const UpdateUserDefinedFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateUserDefinedFunction, request, handler, context);
        }
 
        virtual Model::UpdateWorkflowOutcome UpdateWorkflow(const Model::UpdateWorkflowRequest& request) const;
 
        template<typename UpdateWorkflowRequestT = Model::UpdateWorkflowRequest>
        Model::UpdateWorkflowOutcomeCallable UpdateWorkflowCallable(const UpdateWorkflowRequestT& request) const
        {
            return SubmitCallable(&GlueClient::UpdateWorkflow, request);
        }
 
        template<typename UpdateWorkflowRequestT = Model::UpdateWorkflowRequest>
        void UpdateWorkflowAsync(const UpdateWorkflowRequestT& request, const UpdateWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&GlueClient::UpdateWorkflow, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<GlueEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<GlueClient>;
      void init(const GlueClientConfiguration& clientConfiguration);
 
      GlueClientConfiguration m_clientConfiguration;
      std::shared_ptr<GlueEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Glue
} // namespace Aws