GlueClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/glue/GluePaginationBase.h>
#include <aws/glue/GlueServiceClientModel.h>
#include <aws/glue/GlueWaiter.h>
#include <aws/glue/Glue_EXPORTS.h>
 
namespace Aws {
namespace Glue {
class AWS_GLUE_API GlueClient : public Aws::Client::AWSJsonClient,
                                public Aws::Client::ClientWithAsyncTemplateMethods<GlueClient>,
                                public GluePaginationBase<GlueClient>,
                                public GlueWaiter<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::DeleteConnectionTypeOutcome DeleteConnectionType(const Model::DeleteConnectionTypeRequest& request) const;
 
  template <typename DeleteConnectionTypeRequestT = Model::DeleteConnectionTypeRequest>
  Model::DeleteConnectionTypeOutcomeCallable DeleteConnectionTypeCallable(const DeleteConnectionTypeRequestT& request) const {
    return SubmitCallable(&GlueClient::DeleteConnectionType, request);
  }
 
  template <typename DeleteConnectionTypeRequestT = Model::DeleteConnectionTypeRequest>
  void DeleteConnectionTypeAsync(const DeleteConnectionTypeRequestT& request, const DeleteConnectionTypeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueClient::DeleteConnectionType, 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::DeleteIntegrationResourcePropertyOutcome DeleteIntegrationResourceProperty(
      const Model::DeleteIntegrationResourcePropertyRequest& request) const;
 
  template <typename DeleteIntegrationResourcePropertyRequestT = Model::DeleteIntegrationResourcePropertyRequest>
  Model::DeleteIntegrationResourcePropertyOutcomeCallable DeleteIntegrationResourcePropertyCallable(
      const DeleteIntegrationResourcePropertyRequestT& request) const {
    return SubmitCallable(&GlueClient::DeleteIntegrationResourceProperty, request);
  }
 
  template <typename DeleteIntegrationResourcePropertyRequestT = Model::DeleteIntegrationResourcePropertyRequest>
  void DeleteIntegrationResourcePropertyAsync(const DeleteIntegrationResourcePropertyRequestT& request,
                                              const DeleteIntegrationResourcePropertyResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueClient::DeleteIntegrationResourceProperty, 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::GetMaterializedViewRefreshTaskRunOutcome GetMaterializedViewRefreshTaskRun(
      const Model::GetMaterializedViewRefreshTaskRunRequest& request) const;
 
  template <typename GetMaterializedViewRefreshTaskRunRequestT = Model::GetMaterializedViewRefreshTaskRunRequest>
  Model::GetMaterializedViewRefreshTaskRunOutcomeCallable GetMaterializedViewRefreshTaskRunCallable(
      const GetMaterializedViewRefreshTaskRunRequestT& request) const {
    return SubmitCallable(&GlueClient::GetMaterializedViewRefreshTaskRun, request);
  }
 
  template <typename GetMaterializedViewRefreshTaskRunRequestT = Model::GetMaterializedViewRefreshTaskRunRequest>
  void GetMaterializedViewRefreshTaskRunAsync(const GetMaterializedViewRefreshTaskRunRequestT& request,
                                              const GetMaterializedViewRefreshTaskRunResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueClient::GetMaterializedViewRefreshTaskRun, 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::ListIntegrationResourcePropertiesOutcome ListIntegrationResourceProperties(
      const Model::ListIntegrationResourcePropertiesRequest& request = {}) const;
 
  template <typename ListIntegrationResourcePropertiesRequestT = Model::ListIntegrationResourcePropertiesRequest>
  Model::ListIntegrationResourcePropertiesOutcomeCallable ListIntegrationResourcePropertiesCallable(
      const ListIntegrationResourcePropertiesRequestT& request = {}) const {
    return SubmitCallable(&GlueClient::ListIntegrationResourceProperties, request);
  }
 
  template <typename ListIntegrationResourcePropertiesRequestT = Model::ListIntegrationResourcePropertiesRequest>
  void ListIntegrationResourcePropertiesAsync(const ListIntegrationResourcePropertiesResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const ListIntegrationResourcePropertiesRequestT& request = {}) const {
    return SubmitAsync(&GlueClient::ListIntegrationResourceProperties, 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::ListMaterializedViewRefreshTaskRunsOutcome ListMaterializedViewRefreshTaskRuns(
      const Model::ListMaterializedViewRefreshTaskRunsRequest& request) const;
 
  template <typename ListMaterializedViewRefreshTaskRunsRequestT = Model::ListMaterializedViewRefreshTaskRunsRequest>
  Model::ListMaterializedViewRefreshTaskRunsOutcomeCallable ListMaterializedViewRefreshTaskRunsCallable(
      const ListMaterializedViewRefreshTaskRunsRequestT& request) const {
    return SubmitCallable(&GlueClient::ListMaterializedViewRefreshTaskRuns, request);
  }
 
  template <typename ListMaterializedViewRefreshTaskRunsRequestT = Model::ListMaterializedViewRefreshTaskRunsRequest>
  void ListMaterializedViewRefreshTaskRunsAsync(const ListMaterializedViewRefreshTaskRunsRequestT& request,
                                                const ListMaterializedViewRefreshTaskRunsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueClient::ListMaterializedViewRefreshTaskRuns, 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::RegisterConnectionTypeOutcome RegisterConnectionType(const Model::RegisterConnectionTypeRequest& request) const;
 
  template <typename RegisterConnectionTypeRequestT = Model::RegisterConnectionTypeRequest>
  Model::RegisterConnectionTypeOutcomeCallable RegisterConnectionTypeCallable(const RegisterConnectionTypeRequestT& request) const {
    return SubmitCallable(&GlueClient::RegisterConnectionType, request);
  }
 
  template <typename RegisterConnectionTypeRequestT = Model::RegisterConnectionTypeRequest>
  void RegisterConnectionTypeAsync(const RegisterConnectionTypeRequestT& request,
                                   const RegisterConnectionTypeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueClient::RegisterConnectionType, 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::StartMaterializedViewRefreshTaskRunOutcome StartMaterializedViewRefreshTaskRun(
      const Model::StartMaterializedViewRefreshTaskRunRequest& request) const;
 
  template <typename StartMaterializedViewRefreshTaskRunRequestT = Model::StartMaterializedViewRefreshTaskRunRequest>
  Model::StartMaterializedViewRefreshTaskRunOutcomeCallable StartMaterializedViewRefreshTaskRunCallable(
      const StartMaterializedViewRefreshTaskRunRequestT& request) const {
    return SubmitCallable(&GlueClient::StartMaterializedViewRefreshTaskRun, request);
  }
 
  template <typename StartMaterializedViewRefreshTaskRunRequestT = Model::StartMaterializedViewRefreshTaskRunRequest>
  void StartMaterializedViewRefreshTaskRunAsync(const StartMaterializedViewRefreshTaskRunRequestT& request,
                                                const StartMaterializedViewRefreshTaskRunResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueClient::StartMaterializedViewRefreshTaskRun, 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::StopMaterializedViewRefreshTaskRunOutcome StopMaterializedViewRefreshTaskRun(
      const Model::StopMaterializedViewRefreshTaskRunRequest& request) const;
 
  template <typename StopMaterializedViewRefreshTaskRunRequestT = Model::StopMaterializedViewRefreshTaskRunRequest>
  Model::StopMaterializedViewRefreshTaskRunOutcomeCallable StopMaterializedViewRefreshTaskRunCallable(
      const StopMaterializedViewRefreshTaskRunRequestT& request) const {
    return SubmitCallable(&GlueClient::StopMaterializedViewRefreshTaskRun, request);
  }
 
  template <typename StopMaterializedViewRefreshTaskRunRequestT = Model::StopMaterializedViewRefreshTaskRunRequest>
  void StopMaterializedViewRefreshTaskRunAsync(const StopMaterializedViewRefreshTaskRunRequestT& request,
                                               const StopMaterializedViewRefreshTaskRunResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&GlueClient::StopMaterializedViewRefreshTaskRun, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<GlueEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<GlueClient>;
  void init(const GlueClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, GlueError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  GlueClientConfiguration m_clientConfiguration;
  std::shared_ptr<GlueEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Glue
}  // namespace Aws