AthenaClient.h

 
#pragma once
#include <aws/athena/AthenaPaginationBase.h>
#include <aws/athena/AthenaServiceClientModel.h>
#include <aws/athena/AthenaWaiter.h>
#include <aws/athena/Athena_EXPORTS.h>
#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>
 
namespace Aws {
namespace Athena {
class AWS_ATHENA_API AthenaClient : public Aws::Client::AWSJsonClient,
                                    public Aws::Client::ClientWithAsyncTemplateMethods<AthenaClient>,
                                    public AthenaPaginationBase<AthenaClient>,
                                    public AthenaWaiter<AthenaClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AthenaClientConfiguration ClientConfigurationType;
  typedef AthenaEndpointProvider EndpointProviderType;
 
  AthenaClient(const Aws::Athena::AthenaClientConfiguration& clientConfiguration = Aws::Athena::AthenaClientConfiguration(),
               std::shared_ptr<AthenaEndpointProviderBase> endpointProvider = nullptr);
 
  AthenaClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<AthenaEndpointProviderBase> endpointProvider = nullptr,
               const Aws::Athena::AthenaClientConfiguration& clientConfiguration = Aws::Athena::AthenaClientConfiguration());
 
  AthenaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
               std::shared_ptr<AthenaEndpointProviderBase> endpointProvider = nullptr,
               const Aws::Athena::AthenaClientConfiguration& clientConfiguration = Aws::Athena::AthenaClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AthenaClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AthenaClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AthenaClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
               const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AthenaClient();
 
  virtual Model::BatchGetNamedQueryOutcome BatchGetNamedQuery(const Model::BatchGetNamedQueryRequest& request) const;
 
  template <typename BatchGetNamedQueryRequestT = Model::BatchGetNamedQueryRequest>
  Model::BatchGetNamedQueryOutcomeCallable BatchGetNamedQueryCallable(const BatchGetNamedQueryRequestT& request) const {
    return SubmitCallable(&AthenaClient::BatchGetNamedQuery, request);
  }
 
  template <typename BatchGetNamedQueryRequestT = Model::BatchGetNamedQueryRequest>
  void BatchGetNamedQueryAsync(const BatchGetNamedQueryRequestT& request, const BatchGetNamedQueryResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::BatchGetNamedQuery, request, handler, context);
  }
 
  virtual Model::BatchGetPreparedStatementOutcome BatchGetPreparedStatement(const Model::BatchGetPreparedStatementRequest& request) const;
 
  template <typename BatchGetPreparedStatementRequestT = Model::BatchGetPreparedStatementRequest>
  Model::BatchGetPreparedStatementOutcomeCallable BatchGetPreparedStatementCallable(
      const BatchGetPreparedStatementRequestT& request) const {
    return SubmitCallable(&AthenaClient::BatchGetPreparedStatement, request);
  }
 
  template <typename BatchGetPreparedStatementRequestT = Model::BatchGetPreparedStatementRequest>
  void BatchGetPreparedStatementAsync(const BatchGetPreparedStatementRequestT& request,
                                      const BatchGetPreparedStatementResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::BatchGetPreparedStatement, request, handler, context);
  }
 
  virtual Model::BatchGetQueryExecutionOutcome BatchGetQueryExecution(const Model::BatchGetQueryExecutionRequest& request) const;
 
  template <typename BatchGetQueryExecutionRequestT = Model::BatchGetQueryExecutionRequest>
  Model::BatchGetQueryExecutionOutcomeCallable BatchGetQueryExecutionCallable(const BatchGetQueryExecutionRequestT& request) const {
    return SubmitCallable(&AthenaClient::BatchGetQueryExecution, request);
  }
 
  template <typename BatchGetQueryExecutionRequestT = Model::BatchGetQueryExecutionRequest>
  void BatchGetQueryExecutionAsync(const BatchGetQueryExecutionRequestT& request,
                                   const BatchGetQueryExecutionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::BatchGetQueryExecution, request, handler, context);
  }
 
  virtual Model::CancelCapacityReservationOutcome CancelCapacityReservation(const Model::CancelCapacityReservationRequest& request) const;
 
  template <typename CancelCapacityReservationRequestT = Model::CancelCapacityReservationRequest>
  Model::CancelCapacityReservationOutcomeCallable CancelCapacityReservationCallable(
      const CancelCapacityReservationRequestT& request) const {
    return SubmitCallable(&AthenaClient::CancelCapacityReservation, request);
  }
 
  template <typename CancelCapacityReservationRequestT = Model::CancelCapacityReservationRequest>
  void CancelCapacityReservationAsync(const CancelCapacityReservationRequestT& request,
                                      const CancelCapacityReservationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::CancelCapacityReservation, request, handler, context);
  }
 
  virtual Model::CreateCapacityReservationOutcome CreateCapacityReservation(const Model::CreateCapacityReservationRequest& request) const;
 
  template <typename CreateCapacityReservationRequestT = Model::CreateCapacityReservationRequest>
  Model::CreateCapacityReservationOutcomeCallable CreateCapacityReservationCallable(
      const CreateCapacityReservationRequestT& request) const {
    return SubmitCallable(&AthenaClient::CreateCapacityReservation, request);
  }
 
  template <typename CreateCapacityReservationRequestT = Model::CreateCapacityReservationRequest>
  void CreateCapacityReservationAsync(const CreateCapacityReservationRequestT& request,
                                      const CreateCapacityReservationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::CreateCapacityReservation, request, handler, context);
  }
 
  virtual Model::CreateDataCatalogOutcome CreateDataCatalog(const Model::CreateDataCatalogRequest& request) const;
 
  template <typename CreateDataCatalogRequestT = Model::CreateDataCatalogRequest>
  Model::CreateDataCatalogOutcomeCallable CreateDataCatalogCallable(const CreateDataCatalogRequestT& request) const {
    return SubmitCallable(&AthenaClient::CreateDataCatalog, request);
  }
 
  template <typename CreateDataCatalogRequestT = Model::CreateDataCatalogRequest>
  void CreateDataCatalogAsync(const CreateDataCatalogRequestT& request, const CreateDataCatalogResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::CreateDataCatalog, request, handler, context);
  }
 
  virtual Model::CreateNamedQueryOutcome CreateNamedQuery(const Model::CreateNamedQueryRequest& request) const;
 
  template <typename CreateNamedQueryRequestT = Model::CreateNamedQueryRequest>
  Model::CreateNamedQueryOutcomeCallable CreateNamedQueryCallable(const CreateNamedQueryRequestT& request) const {
    return SubmitCallable(&AthenaClient::CreateNamedQuery, request);
  }
 
  template <typename CreateNamedQueryRequestT = Model::CreateNamedQueryRequest>
  void CreateNamedQueryAsync(const CreateNamedQueryRequestT& request, const CreateNamedQueryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::CreateNamedQuery, request, handler, context);
  }
 
  virtual Model::CreateNotebookOutcome CreateNotebook(const Model::CreateNotebookRequest& request) const;
 
  template <typename CreateNotebookRequestT = Model::CreateNotebookRequest>
  Model::CreateNotebookOutcomeCallable CreateNotebookCallable(const CreateNotebookRequestT& request) const {
    return SubmitCallable(&AthenaClient::CreateNotebook, request);
  }
 
  template <typename CreateNotebookRequestT = Model::CreateNotebookRequest>
  void CreateNotebookAsync(const CreateNotebookRequestT& request, const CreateNotebookResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::CreateNotebook, request, handler, context);
  }
 
  virtual Model::CreatePreparedStatementOutcome CreatePreparedStatement(const Model::CreatePreparedStatementRequest& request) const;
 
  template <typename CreatePreparedStatementRequestT = Model::CreatePreparedStatementRequest>
  Model::CreatePreparedStatementOutcomeCallable CreatePreparedStatementCallable(const CreatePreparedStatementRequestT& request) const {
    return SubmitCallable(&AthenaClient::CreatePreparedStatement, request);
  }
 
  template <typename CreatePreparedStatementRequestT = Model::CreatePreparedStatementRequest>
  void CreatePreparedStatementAsync(const CreatePreparedStatementRequestT& request,
                                    const CreatePreparedStatementResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::CreatePreparedStatement, request, handler, context);
  }
 
  virtual Model::CreatePresignedNotebookUrlOutcome CreatePresignedNotebookUrl(
      const Model::CreatePresignedNotebookUrlRequest& request) const;
 
  template <typename CreatePresignedNotebookUrlRequestT = Model::CreatePresignedNotebookUrlRequest>
  Model::CreatePresignedNotebookUrlOutcomeCallable CreatePresignedNotebookUrlCallable(
      const CreatePresignedNotebookUrlRequestT& request) const {
    return SubmitCallable(&AthenaClient::CreatePresignedNotebookUrl, request);
  }
 
  template <typename CreatePresignedNotebookUrlRequestT = Model::CreatePresignedNotebookUrlRequest>
  void CreatePresignedNotebookUrlAsync(const CreatePresignedNotebookUrlRequestT& request,
                                       const CreatePresignedNotebookUrlResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::CreatePresignedNotebookUrl, request, handler, context);
  }
 
  virtual Model::CreateWorkGroupOutcome CreateWorkGroup(const Model::CreateWorkGroupRequest& request) const;
 
  template <typename CreateWorkGroupRequestT = Model::CreateWorkGroupRequest>
  Model::CreateWorkGroupOutcomeCallable CreateWorkGroupCallable(const CreateWorkGroupRequestT& request) const {
    return SubmitCallable(&AthenaClient::CreateWorkGroup, request);
  }
 
  template <typename CreateWorkGroupRequestT = Model::CreateWorkGroupRequest>
  void CreateWorkGroupAsync(const CreateWorkGroupRequestT& request, const CreateWorkGroupResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::CreateWorkGroup, request, handler, context);
  }
 
  virtual Model::DeleteCapacityReservationOutcome DeleteCapacityReservation(const Model::DeleteCapacityReservationRequest& request) const;
 
  template <typename DeleteCapacityReservationRequestT = Model::DeleteCapacityReservationRequest>
  Model::DeleteCapacityReservationOutcomeCallable DeleteCapacityReservationCallable(
      const DeleteCapacityReservationRequestT& request) const {
    return SubmitCallable(&AthenaClient::DeleteCapacityReservation, request);
  }
 
  template <typename DeleteCapacityReservationRequestT = Model::DeleteCapacityReservationRequest>
  void DeleteCapacityReservationAsync(const DeleteCapacityReservationRequestT& request,
                                      const DeleteCapacityReservationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::DeleteCapacityReservation, request, handler, context);
  }
 
  virtual Model::DeleteDataCatalogOutcome DeleteDataCatalog(const Model::DeleteDataCatalogRequest& request) const;
 
  template <typename DeleteDataCatalogRequestT = Model::DeleteDataCatalogRequest>
  Model::DeleteDataCatalogOutcomeCallable DeleteDataCatalogCallable(const DeleteDataCatalogRequestT& request) const {
    return SubmitCallable(&AthenaClient::DeleteDataCatalog, request);
  }
 
  template <typename DeleteDataCatalogRequestT = Model::DeleteDataCatalogRequest>
  void DeleteDataCatalogAsync(const DeleteDataCatalogRequestT& request, const DeleteDataCatalogResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::DeleteDataCatalog, request, handler, context);
  }
 
  virtual Model::DeleteNamedQueryOutcome DeleteNamedQuery(const Model::DeleteNamedQueryRequest& request) const;
 
  template <typename DeleteNamedQueryRequestT = Model::DeleteNamedQueryRequest>
  Model::DeleteNamedQueryOutcomeCallable DeleteNamedQueryCallable(const DeleteNamedQueryRequestT& request) const {
    return SubmitCallable(&AthenaClient::DeleteNamedQuery, request);
  }
 
  template <typename DeleteNamedQueryRequestT = Model::DeleteNamedQueryRequest>
  void DeleteNamedQueryAsync(const DeleteNamedQueryRequestT& request, const DeleteNamedQueryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::DeleteNamedQuery, request, handler, context);
  }
 
  virtual Model::DeleteNotebookOutcome DeleteNotebook(const Model::DeleteNotebookRequest& request) const;
 
  template <typename DeleteNotebookRequestT = Model::DeleteNotebookRequest>
  Model::DeleteNotebookOutcomeCallable DeleteNotebookCallable(const DeleteNotebookRequestT& request) const {
    return SubmitCallable(&AthenaClient::DeleteNotebook, request);
  }
 
  template <typename DeleteNotebookRequestT = Model::DeleteNotebookRequest>
  void DeleteNotebookAsync(const DeleteNotebookRequestT& request, const DeleteNotebookResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::DeleteNotebook, request, handler, context);
  }
 
  virtual Model::DeletePreparedStatementOutcome DeletePreparedStatement(const Model::DeletePreparedStatementRequest& request) const;
 
  template <typename DeletePreparedStatementRequestT = Model::DeletePreparedStatementRequest>
  Model::DeletePreparedStatementOutcomeCallable DeletePreparedStatementCallable(const DeletePreparedStatementRequestT& request) const {
    return SubmitCallable(&AthenaClient::DeletePreparedStatement, request);
  }
 
  template <typename DeletePreparedStatementRequestT = Model::DeletePreparedStatementRequest>
  void DeletePreparedStatementAsync(const DeletePreparedStatementRequestT& request,
                                    const DeletePreparedStatementResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::DeletePreparedStatement, request, handler, context);
  }
 
  virtual Model::DeleteWorkGroupOutcome DeleteWorkGroup(const Model::DeleteWorkGroupRequest& request) const;
 
  template <typename DeleteWorkGroupRequestT = Model::DeleteWorkGroupRequest>
  Model::DeleteWorkGroupOutcomeCallable DeleteWorkGroupCallable(const DeleteWorkGroupRequestT& request) const {
    return SubmitCallable(&AthenaClient::DeleteWorkGroup, request);
  }
 
  template <typename DeleteWorkGroupRequestT = Model::DeleteWorkGroupRequest>
  void DeleteWorkGroupAsync(const DeleteWorkGroupRequestT& request, const DeleteWorkGroupResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::DeleteWorkGroup, request, handler, context);
  }
 
  virtual Model::ExportNotebookOutcome ExportNotebook(const Model::ExportNotebookRequest& request) const;
 
  template <typename ExportNotebookRequestT = Model::ExportNotebookRequest>
  Model::ExportNotebookOutcomeCallable ExportNotebookCallable(const ExportNotebookRequestT& request) const {
    return SubmitCallable(&AthenaClient::ExportNotebook, request);
  }
 
  template <typename ExportNotebookRequestT = Model::ExportNotebookRequest>
  void ExportNotebookAsync(const ExportNotebookRequestT& request, const ExportNotebookResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ExportNotebook, request, handler, context);
  }
 
  virtual Model::GetCalculationExecutionOutcome GetCalculationExecution(const Model::GetCalculationExecutionRequest& request) const;
 
  template <typename GetCalculationExecutionRequestT = Model::GetCalculationExecutionRequest>
  Model::GetCalculationExecutionOutcomeCallable GetCalculationExecutionCallable(const GetCalculationExecutionRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetCalculationExecution, request);
  }
 
  template <typename GetCalculationExecutionRequestT = Model::GetCalculationExecutionRequest>
  void GetCalculationExecutionAsync(const GetCalculationExecutionRequestT& request,
                                    const GetCalculationExecutionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetCalculationExecution, request, handler, context);
  }
 
  virtual Model::GetCalculationExecutionCodeOutcome GetCalculationExecutionCode(
      const Model::GetCalculationExecutionCodeRequest& request) const;
 
  template <typename GetCalculationExecutionCodeRequestT = Model::GetCalculationExecutionCodeRequest>
  Model::GetCalculationExecutionCodeOutcomeCallable GetCalculationExecutionCodeCallable(
      const GetCalculationExecutionCodeRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetCalculationExecutionCode, request);
  }
 
  template <typename GetCalculationExecutionCodeRequestT = Model::GetCalculationExecutionCodeRequest>
  void GetCalculationExecutionCodeAsync(const GetCalculationExecutionCodeRequestT& request,
                                        const GetCalculationExecutionCodeResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetCalculationExecutionCode, request, handler, context);
  }
 
  virtual Model::GetCalculationExecutionStatusOutcome GetCalculationExecutionStatus(
      const Model::GetCalculationExecutionStatusRequest& request) const;
 
  template <typename GetCalculationExecutionStatusRequestT = Model::GetCalculationExecutionStatusRequest>
  Model::GetCalculationExecutionStatusOutcomeCallable GetCalculationExecutionStatusCallable(
      const GetCalculationExecutionStatusRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetCalculationExecutionStatus, request);
  }
 
  template <typename GetCalculationExecutionStatusRequestT = Model::GetCalculationExecutionStatusRequest>
  void GetCalculationExecutionStatusAsync(const GetCalculationExecutionStatusRequestT& request,
                                          const GetCalculationExecutionStatusResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetCalculationExecutionStatus, request, handler, context);
  }
 
  virtual Model::GetCapacityAssignmentConfigurationOutcome GetCapacityAssignmentConfiguration(
      const Model::GetCapacityAssignmentConfigurationRequest& request) const;
 
  template <typename GetCapacityAssignmentConfigurationRequestT = Model::GetCapacityAssignmentConfigurationRequest>
  Model::GetCapacityAssignmentConfigurationOutcomeCallable GetCapacityAssignmentConfigurationCallable(
      const GetCapacityAssignmentConfigurationRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetCapacityAssignmentConfiguration, request);
  }
 
  template <typename GetCapacityAssignmentConfigurationRequestT = Model::GetCapacityAssignmentConfigurationRequest>
  void GetCapacityAssignmentConfigurationAsync(const GetCapacityAssignmentConfigurationRequestT& request,
                                               const GetCapacityAssignmentConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetCapacityAssignmentConfiguration, request, handler, context);
  }
 
  virtual Model::GetCapacityReservationOutcome GetCapacityReservation(const Model::GetCapacityReservationRequest& request) const;
 
  template <typename GetCapacityReservationRequestT = Model::GetCapacityReservationRequest>
  Model::GetCapacityReservationOutcomeCallable GetCapacityReservationCallable(const GetCapacityReservationRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetCapacityReservation, request);
  }
 
  template <typename GetCapacityReservationRequestT = Model::GetCapacityReservationRequest>
  void GetCapacityReservationAsync(const GetCapacityReservationRequestT& request,
                                   const GetCapacityReservationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetCapacityReservation, request, handler, context);
  }
 
  virtual Model::GetDataCatalogOutcome GetDataCatalog(const Model::GetDataCatalogRequest& request) const;
 
  template <typename GetDataCatalogRequestT = Model::GetDataCatalogRequest>
  Model::GetDataCatalogOutcomeCallable GetDataCatalogCallable(const GetDataCatalogRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetDataCatalog, request);
  }
 
  template <typename GetDataCatalogRequestT = Model::GetDataCatalogRequest>
  void GetDataCatalogAsync(const GetDataCatalogRequestT& request, const GetDataCatalogResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetDataCatalog, 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(&AthenaClient::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(&AthenaClient::GetDatabase, request, handler, context);
  }
 
  virtual Model::GetNamedQueryOutcome GetNamedQuery(const Model::GetNamedQueryRequest& request) const;
 
  template <typename GetNamedQueryRequestT = Model::GetNamedQueryRequest>
  Model::GetNamedQueryOutcomeCallable GetNamedQueryCallable(const GetNamedQueryRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetNamedQuery, request);
  }
 
  template <typename GetNamedQueryRequestT = Model::GetNamedQueryRequest>
  void GetNamedQueryAsync(const GetNamedQueryRequestT& request, const GetNamedQueryResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetNamedQuery, request, handler, context);
  }
 
  virtual Model::GetNotebookMetadataOutcome GetNotebookMetadata(const Model::GetNotebookMetadataRequest& request) const;
 
  template <typename GetNotebookMetadataRequestT = Model::GetNotebookMetadataRequest>
  Model::GetNotebookMetadataOutcomeCallable GetNotebookMetadataCallable(const GetNotebookMetadataRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetNotebookMetadata, request);
  }
 
  template <typename GetNotebookMetadataRequestT = Model::GetNotebookMetadataRequest>
  void GetNotebookMetadataAsync(const GetNotebookMetadataRequestT& request, const GetNotebookMetadataResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetNotebookMetadata, request, handler, context);
  }
 
  virtual Model::GetPreparedStatementOutcome GetPreparedStatement(const Model::GetPreparedStatementRequest& request) const;
 
  template <typename GetPreparedStatementRequestT = Model::GetPreparedStatementRequest>
  Model::GetPreparedStatementOutcomeCallable GetPreparedStatementCallable(const GetPreparedStatementRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetPreparedStatement, request);
  }
 
  template <typename GetPreparedStatementRequestT = Model::GetPreparedStatementRequest>
  void GetPreparedStatementAsync(const GetPreparedStatementRequestT& request, const GetPreparedStatementResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetPreparedStatement, request, handler, context);
  }
 
  virtual Model::GetQueryExecutionOutcome GetQueryExecution(const Model::GetQueryExecutionRequest& request) const;
 
  template <typename GetQueryExecutionRequestT = Model::GetQueryExecutionRequest>
  Model::GetQueryExecutionOutcomeCallable GetQueryExecutionCallable(const GetQueryExecutionRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetQueryExecution, request);
  }
 
  template <typename GetQueryExecutionRequestT = Model::GetQueryExecutionRequest>
  void GetQueryExecutionAsync(const GetQueryExecutionRequestT& request, const GetQueryExecutionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetQueryExecution, request, handler, context);
  }
 
  virtual Model::GetQueryResultsOutcome GetQueryResults(const Model::GetQueryResultsRequest& request) const;
 
  template <typename GetQueryResultsRequestT = Model::GetQueryResultsRequest>
  Model::GetQueryResultsOutcomeCallable GetQueryResultsCallable(const GetQueryResultsRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetQueryResults, request);
  }
 
  template <typename GetQueryResultsRequestT = Model::GetQueryResultsRequest>
  void GetQueryResultsAsync(const GetQueryResultsRequestT& request, const GetQueryResultsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetQueryResults, request, handler, context);
  }
 
  virtual Model::GetQueryRuntimeStatisticsOutcome GetQueryRuntimeStatistics(const Model::GetQueryRuntimeStatisticsRequest& request) const;
 
  template <typename GetQueryRuntimeStatisticsRequestT = Model::GetQueryRuntimeStatisticsRequest>
  Model::GetQueryRuntimeStatisticsOutcomeCallable GetQueryRuntimeStatisticsCallable(
      const GetQueryRuntimeStatisticsRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetQueryRuntimeStatistics, request);
  }
 
  template <typename GetQueryRuntimeStatisticsRequestT = Model::GetQueryRuntimeStatisticsRequest>
  void GetQueryRuntimeStatisticsAsync(const GetQueryRuntimeStatisticsRequestT& request,
                                      const GetQueryRuntimeStatisticsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetQueryRuntimeStatistics, request, handler, context);
  }
 
  virtual Model::GetResourceDashboardOutcome GetResourceDashboard(const Model::GetResourceDashboardRequest& request) const;
 
  template <typename GetResourceDashboardRequestT = Model::GetResourceDashboardRequest>
  Model::GetResourceDashboardOutcomeCallable GetResourceDashboardCallable(const GetResourceDashboardRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetResourceDashboard, request);
  }
 
  template <typename GetResourceDashboardRequestT = Model::GetResourceDashboardRequest>
  void GetResourceDashboardAsync(const GetResourceDashboardRequestT& request, const GetResourceDashboardResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetResourceDashboard, 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(&AthenaClient::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(&AthenaClient::GetSession, request, handler, context);
  }
 
  virtual Model::GetSessionEndpointOutcome GetSessionEndpoint(const Model::GetSessionEndpointRequest& request) const;
 
  template <typename GetSessionEndpointRequestT = Model::GetSessionEndpointRequest>
  Model::GetSessionEndpointOutcomeCallable GetSessionEndpointCallable(const GetSessionEndpointRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetSessionEndpoint, request);
  }
 
  template <typename GetSessionEndpointRequestT = Model::GetSessionEndpointRequest>
  void GetSessionEndpointAsync(const GetSessionEndpointRequestT& request, const GetSessionEndpointResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetSessionEndpoint, request, handler, context);
  }
 
  virtual Model::GetSessionStatusOutcome GetSessionStatus(const Model::GetSessionStatusRequest& request) const;
 
  template <typename GetSessionStatusRequestT = Model::GetSessionStatusRequest>
  Model::GetSessionStatusOutcomeCallable GetSessionStatusCallable(const GetSessionStatusRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetSessionStatus, request);
  }
 
  template <typename GetSessionStatusRequestT = Model::GetSessionStatusRequest>
  void GetSessionStatusAsync(const GetSessionStatusRequestT& request, const GetSessionStatusResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetSessionStatus, request, handler, context);
  }
 
  virtual Model::GetTableMetadataOutcome GetTableMetadata(const Model::GetTableMetadataRequest& request) const;
 
  template <typename GetTableMetadataRequestT = Model::GetTableMetadataRequest>
  Model::GetTableMetadataOutcomeCallable GetTableMetadataCallable(const GetTableMetadataRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetTableMetadata, request);
  }
 
  template <typename GetTableMetadataRequestT = Model::GetTableMetadataRequest>
  void GetTableMetadataAsync(const GetTableMetadataRequestT& request, const GetTableMetadataResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetTableMetadata, request, handler, context);
  }
 
  virtual Model::GetWorkGroupOutcome GetWorkGroup(const Model::GetWorkGroupRequest& request) const;
 
  template <typename GetWorkGroupRequestT = Model::GetWorkGroupRequest>
  Model::GetWorkGroupOutcomeCallable GetWorkGroupCallable(const GetWorkGroupRequestT& request) const {
    return SubmitCallable(&AthenaClient::GetWorkGroup, request);
  }
 
  template <typename GetWorkGroupRequestT = Model::GetWorkGroupRequest>
  void GetWorkGroupAsync(const GetWorkGroupRequestT& request, const GetWorkGroupResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::GetWorkGroup, request, handler, context);
  }
 
  virtual Model::ImportNotebookOutcome ImportNotebook(const Model::ImportNotebookRequest& request) const;
 
  template <typename ImportNotebookRequestT = Model::ImportNotebookRequest>
  Model::ImportNotebookOutcomeCallable ImportNotebookCallable(const ImportNotebookRequestT& request) const {
    return SubmitCallable(&AthenaClient::ImportNotebook, request);
  }
 
  template <typename ImportNotebookRequestT = Model::ImportNotebookRequest>
  void ImportNotebookAsync(const ImportNotebookRequestT& request, const ImportNotebookResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ImportNotebook, request, handler, context);
  }
 
  virtual Model::ListApplicationDPUSizesOutcome ListApplicationDPUSizes(const Model::ListApplicationDPUSizesRequest& request = {}) const;
 
  template <typename ListApplicationDPUSizesRequestT = Model::ListApplicationDPUSizesRequest>
  Model::ListApplicationDPUSizesOutcomeCallable ListApplicationDPUSizesCallable(const ListApplicationDPUSizesRequestT& request = {}) const {
    return SubmitCallable(&AthenaClient::ListApplicationDPUSizes, request);
  }
 
  template <typename ListApplicationDPUSizesRequestT = Model::ListApplicationDPUSizesRequest>
  void ListApplicationDPUSizesAsync(const ListApplicationDPUSizesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListApplicationDPUSizesRequestT& request = {}) const {
    return SubmitAsync(&AthenaClient::ListApplicationDPUSizes, request, handler, context);
  }
 
  virtual Model::ListCalculationExecutionsOutcome ListCalculationExecutions(const Model::ListCalculationExecutionsRequest& request) const;
 
  template <typename ListCalculationExecutionsRequestT = Model::ListCalculationExecutionsRequest>
  Model::ListCalculationExecutionsOutcomeCallable ListCalculationExecutionsCallable(
      const ListCalculationExecutionsRequestT& request) const {
    return SubmitCallable(&AthenaClient::ListCalculationExecutions, request);
  }
 
  template <typename ListCalculationExecutionsRequestT = Model::ListCalculationExecutionsRequest>
  void ListCalculationExecutionsAsync(const ListCalculationExecutionsRequestT& request,
                                      const ListCalculationExecutionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ListCalculationExecutions, request, handler, context);
  }
 
  virtual Model::ListCapacityReservationsOutcome ListCapacityReservations(const Model::ListCapacityReservationsRequest& request = {}) const;
 
  template <typename ListCapacityReservationsRequestT = Model::ListCapacityReservationsRequest>
  Model::ListCapacityReservationsOutcomeCallable ListCapacityReservationsCallable(
      const ListCapacityReservationsRequestT& request = {}) const {
    return SubmitCallable(&AthenaClient::ListCapacityReservations, request);
  }
 
  template <typename ListCapacityReservationsRequestT = Model::ListCapacityReservationsRequest>
  void ListCapacityReservationsAsync(const ListCapacityReservationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListCapacityReservationsRequestT& request = {}) const {
    return SubmitAsync(&AthenaClient::ListCapacityReservations, request, handler, context);
  }
 
  virtual Model::ListDataCatalogsOutcome ListDataCatalogs(const Model::ListDataCatalogsRequest& request = {}) const;
 
  template <typename ListDataCatalogsRequestT = Model::ListDataCatalogsRequest>
  Model::ListDataCatalogsOutcomeCallable ListDataCatalogsCallable(const ListDataCatalogsRequestT& request = {}) const {
    return SubmitCallable(&AthenaClient::ListDataCatalogs, request);
  }
 
  template <typename ListDataCatalogsRequestT = Model::ListDataCatalogsRequest>
  void ListDataCatalogsAsync(const ListDataCatalogsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListDataCatalogsRequestT& request = {}) const {
    return SubmitAsync(&AthenaClient::ListDataCatalogs, request, handler, context);
  }
 
  virtual Model::ListDatabasesOutcome ListDatabases(const Model::ListDatabasesRequest& request) const;
 
  template <typename ListDatabasesRequestT = Model::ListDatabasesRequest>
  Model::ListDatabasesOutcomeCallable ListDatabasesCallable(const ListDatabasesRequestT& request) const {
    return SubmitCallable(&AthenaClient::ListDatabases, request);
  }
 
  template <typename ListDatabasesRequestT = Model::ListDatabasesRequest>
  void ListDatabasesAsync(const ListDatabasesRequestT& request, const ListDatabasesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ListDatabases, request, handler, context);
  }
 
  virtual Model::ListEngineVersionsOutcome ListEngineVersions(const Model::ListEngineVersionsRequest& request = {}) const;
 
  template <typename ListEngineVersionsRequestT = Model::ListEngineVersionsRequest>
  Model::ListEngineVersionsOutcomeCallable ListEngineVersionsCallable(const ListEngineVersionsRequestT& request = {}) const {
    return SubmitCallable(&AthenaClient::ListEngineVersions, request);
  }
 
  template <typename ListEngineVersionsRequestT = Model::ListEngineVersionsRequest>
  void ListEngineVersionsAsync(const ListEngineVersionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListEngineVersionsRequestT& request = {}) const {
    return SubmitAsync(&AthenaClient::ListEngineVersions, request, handler, context);
  }
 
  virtual Model::ListExecutorsOutcome ListExecutors(const Model::ListExecutorsRequest& request) const;
 
  template <typename ListExecutorsRequestT = Model::ListExecutorsRequest>
  Model::ListExecutorsOutcomeCallable ListExecutorsCallable(const ListExecutorsRequestT& request) const {
    return SubmitCallable(&AthenaClient::ListExecutors, request);
  }
 
  template <typename ListExecutorsRequestT = Model::ListExecutorsRequest>
  void ListExecutorsAsync(const ListExecutorsRequestT& request, const ListExecutorsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ListExecutors, request, handler, context);
  }
 
  virtual Model::ListNamedQueriesOutcome ListNamedQueries(const Model::ListNamedQueriesRequest& request = {}) const;
 
  template <typename ListNamedQueriesRequestT = Model::ListNamedQueriesRequest>
  Model::ListNamedQueriesOutcomeCallable ListNamedQueriesCallable(const ListNamedQueriesRequestT& request = {}) const {
    return SubmitCallable(&AthenaClient::ListNamedQueries, request);
  }
 
  template <typename ListNamedQueriesRequestT = Model::ListNamedQueriesRequest>
  void ListNamedQueriesAsync(const ListNamedQueriesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListNamedQueriesRequestT& request = {}) const {
    return SubmitAsync(&AthenaClient::ListNamedQueries, request, handler, context);
  }
 
  virtual Model::ListNotebookMetadataOutcome ListNotebookMetadata(const Model::ListNotebookMetadataRequest& request) const;
 
  template <typename ListNotebookMetadataRequestT = Model::ListNotebookMetadataRequest>
  Model::ListNotebookMetadataOutcomeCallable ListNotebookMetadataCallable(const ListNotebookMetadataRequestT& request) const {
    return SubmitCallable(&AthenaClient::ListNotebookMetadata, request);
  }
 
  template <typename ListNotebookMetadataRequestT = Model::ListNotebookMetadataRequest>
  void ListNotebookMetadataAsync(const ListNotebookMetadataRequestT& request, const ListNotebookMetadataResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ListNotebookMetadata, request, handler, context);
  }
 
  virtual Model::ListNotebookSessionsOutcome ListNotebookSessions(const Model::ListNotebookSessionsRequest& request) const;
 
  template <typename ListNotebookSessionsRequestT = Model::ListNotebookSessionsRequest>
  Model::ListNotebookSessionsOutcomeCallable ListNotebookSessionsCallable(const ListNotebookSessionsRequestT& request) const {
    return SubmitCallable(&AthenaClient::ListNotebookSessions, request);
  }
 
  template <typename ListNotebookSessionsRequestT = Model::ListNotebookSessionsRequest>
  void ListNotebookSessionsAsync(const ListNotebookSessionsRequestT& request, const ListNotebookSessionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ListNotebookSessions, request, handler, context);
  }
 
  virtual Model::ListPreparedStatementsOutcome ListPreparedStatements(const Model::ListPreparedStatementsRequest& request) const;
 
  template <typename ListPreparedStatementsRequestT = Model::ListPreparedStatementsRequest>
  Model::ListPreparedStatementsOutcomeCallable ListPreparedStatementsCallable(const ListPreparedStatementsRequestT& request) const {
    return SubmitCallable(&AthenaClient::ListPreparedStatements, request);
  }
 
  template <typename ListPreparedStatementsRequestT = Model::ListPreparedStatementsRequest>
  void ListPreparedStatementsAsync(const ListPreparedStatementsRequestT& request,
                                   const ListPreparedStatementsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ListPreparedStatements, request, handler, context);
  }
 
  virtual Model::ListQueryExecutionsOutcome ListQueryExecutions(const Model::ListQueryExecutionsRequest& request = {}) const;
 
  template <typename ListQueryExecutionsRequestT = Model::ListQueryExecutionsRequest>
  Model::ListQueryExecutionsOutcomeCallable ListQueryExecutionsCallable(const ListQueryExecutionsRequestT& request = {}) const {
    return SubmitCallable(&AthenaClient::ListQueryExecutions, request);
  }
 
  template <typename ListQueryExecutionsRequestT = Model::ListQueryExecutionsRequest>
  void ListQueryExecutionsAsync(const ListQueryExecutionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListQueryExecutionsRequestT& request = {}) const {
    return SubmitAsync(&AthenaClient::ListQueryExecutions, 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(&AthenaClient::ListSessions, request);
  }
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  void ListSessionsAsync(const ListSessionsRequestT& request, const ListSessionsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ListSessions, request, handler, context);
  }
 
  virtual Model::ListTableMetadataOutcome ListTableMetadata(const Model::ListTableMetadataRequest& request) const;
 
  template <typename ListTableMetadataRequestT = Model::ListTableMetadataRequest>
  Model::ListTableMetadataOutcomeCallable ListTableMetadataCallable(const ListTableMetadataRequestT& request) const {
    return SubmitCallable(&AthenaClient::ListTableMetadata, request);
  }
 
  template <typename ListTableMetadataRequestT = Model::ListTableMetadataRequest>
  void ListTableMetadataAsync(const ListTableMetadataRequestT& request, const ListTableMetadataResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ListTableMetadata, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&AthenaClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWorkGroupsOutcome ListWorkGroups(const Model::ListWorkGroupsRequest& request = {}) const;
 
  template <typename ListWorkGroupsRequestT = Model::ListWorkGroupsRequest>
  Model::ListWorkGroupsOutcomeCallable ListWorkGroupsCallable(const ListWorkGroupsRequestT& request = {}) const {
    return SubmitCallable(&AthenaClient::ListWorkGroups, request);
  }
 
  template <typename ListWorkGroupsRequestT = Model::ListWorkGroupsRequest>
  void ListWorkGroupsAsync(const ListWorkGroupsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListWorkGroupsRequestT& request = {}) const {
    return SubmitAsync(&AthenaClient::ListWorkGroups, request, handler, context);
  }
 
  virtual Model::PutCapacityAssignmentConfigurationOutcome PutCapacityAssignmentConfiguration(
      const Model::PutCapacityAssignmentConfigurationRequest& request) const;
 
  template <typename PutCapacityAssignmentConfigurationRequestT = Model::PutCapacityAssignmentConfigurationRequest>
  Model::PutCapacityAssignmentConfigurationOutcomeCallable PutCapacityAssignmentConfigurationCallable(
      const PutCapacityAssignmentConfigurationRequestT& request) const {
    return SubmitCallable(&AthenaClient::PutCapacityAssignmentConfiguration, request);
  }
 
  template <typename PutCapacityAssignmentConfigurationRequestT = Model::PutCapacityAssignmentConfigurationRequest>
  void PutCapacityAssignmentConfigurationAsync(const PutCapacityAssignmentConfigurationRequestT& request,
                                               const PutCapacityAssignmentConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::PutCapacityAssignmentConfiguration, request, handler, context);
  }
 
  virtual Model::StartCalculationExecutionOutcome StartCalculationExecution(const Model::StartCalculationExecutionRequest& request) const;
 
  template <typename StartCalculationExecutionRequestT = Model::StartCalculationExecutionRequest>
  Model::StartCalculationExecutionOutcomeCallable StartCalculationExecutionCallable(
      const StartCalculationExecutionRequestT& request) const {
    return SubmitCallable(&AthenaClient::StartCalculationExecution, request);
  }
 
  template <typename StartCalculationExecutionRequestT = Model::StartCalculationExecutionRequest>
  void StartCalculationExecutionAsync(const StartCalculationExecutionRequestT& request,
                                      const StartCalculationExecutionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::StartCalculationExecution, request, handler, context);
  }
 
  virtual Model::StartQueryExecutionOutcome StartQueryExecution(const Model::StartQueryExecutionRequest& request) const;
 
  template <typename StartQueryExecutionRequestT = Model::StartQueryExecutionRequest>
  Model::StartQueryExecutionOutcomeCallable StartQueryExecutionCallable(const StartQueryExecutionRequestT& request) const {
    return SubmitCallable(&AthenaClient::StartQueryExecution, request);
  }
 
  template <typename StartQueryExecutionRequestT = Model::StartQueryExecutionRequest>
  void StartQueryExecutionAsync(const StartQueryExecutionRequestT& request, const StartQueryExecutionResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::StartQueryExecution, request, handler, context);
  }
 
  virtual Model::StartSessionOutcome StartSession(const Model::StartSessionRequest& request) const;
 
  template <typename StartSessionRequestT = Model::StartSessionRequest>
  Model::StartSessionOutcomeCallable StartSessionCallable(const StartSessionRequestT& request) const {
    return SubmitCallable(&AthenaClient::StartSession, request);
  }
 
  template <typename StartSessionRequestT = Model::StartSessionRequest>
  void StartSessionAsync(const StartSessionRequestT& request, const StartSessionResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::StartSession, request, handler, context);
  }
 
  virtual Model::StopCalculationExecutionOutcome StopCalculationExecution(const Model::StopCalculationExecutionRequest& request) const;
 
  template <typename StopCalculationExecutionRequestT = Model::StopCalculationExecutionRequest>
  Model::StopCalculationExecutionOutcomeCallable StopCalculationExecutionCallable(const StopCalculationExecutionRequestT& request) const {
    return SubmitCallable(&AthenaClient::StopCalculationExecution, request);
  }
 
  template <typename StopCalculationExecutionRequestT = Model::StopCalculationExecutionRequest>
  void StopCalculationExecutionAsync(const StopCalculationExecutionRequestT& request,
                                     const StopCalculationExecutionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::StopCalculationExecution, request, handler, context);
  }
 
  virtual Model::StopQueryExecutionOutcome StopQueryExecution(const Model::StopQueryExecutionRequest& request) const;
 
  template <typename StopQueryExecutionRequestT = Model::StopQueryExecutionRequest>
  Model::StopQueryExecutionOutcomeCallable StopQueryExecutionCallable(const StopQueryExecutionRequestT& request) const {
    return SubmitCallable(&AthenaClient::StopQueryExecution, request);
  }
 
  template <typename StopQueryExecutionRequestT = Model::StopQueryExecutionRequest>
  void StopQueryExecutionAsync(const StopQueryExecutionRequestT& request, const StopQueryExecutionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::StopQueryExecution, 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(&AthenaClient::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(&AthenaClient::TagResource, request, handler, context);
  }
 
  virtual Model::TerminateSessionOutcome TerminateSession(const Model::TerminateSessionRequest& request) const;
 
  template <typename TerminateSessionRequestT = Model::TerminateSessionRequest>
  Model::TerminateSessionOutcomeCallable TerminateSessionCallable(const TerminateSessionRequestT& request) const {
    return SubmitCallable(&AthenaClient::TerminateSession, request);
  }
 
  template <typename TerminateSessionRequestT = Model::TerminateSessionRequest>
  void TerminateSessionAsync(const TerminateSessionRequestT& request, const TerminateSessionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::TerminateSession, 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(&AthenaClient::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(&AthenaClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateCapacityReservationOutcome UpdateCapacityReservation(const Model::UpdateCapacityReservationRequest& request) const;
 
  template <typename UpdateCapacityReservationRequestT = Model::UpdateCapacityReservationRequest>
  Model::UpdateCapacityReservationOutcomeCallable UpdateCapacityReservationCallable(
      const UpdateCapacityReservationRequestT& request) const {
    return SubmitCallable(&AthenaClient::UpdateCapacityReservation, request);
  }
 
  template <typename UpdateCapacityReservationRequestT = Model::UpdateCapacityReservationRequest>
  void UpdateCapacityReservationAsync(const UpdateCapacityReservationRequestT& request,
                                      const UpdateCapacityReservationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::UpdateCapacityReservation, request, handler, context);
  }
 
  virtual Model::UpdateDataCatalogOutcome UpdateDataCatalog(const Model::UpdateDataCatalogRequest& request) const;
 
  template <typename UpdateDataCatalogRequestT = Model::UpdateDataCatalogRequest>
  Model::UpdateDataCatalogOutcomeCallable UpdateDataCatalogCallable(const UpdateDataCatalogRequestT& request) const {
    return SubmitCallable(&AthenaClient::UpdateDataCatalog, request);
  }
 
  template <typename UpdateDataCatalogRequestT = Model::UpdateDataCatalogRequest>
  void UpdateDataCatalogAsync(const UpdateDataCatalogRequestT& request, const UpdateDataCatalogResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::UpdateDataCatalog, request, handler, context);
  }
 
  virtual Model::UpdateNamedQueryOutcome UpdateNamedQuery(const Model::UpdateNamedQueryRequest& request) const;
 
  template <typename UpdateNamedQueryRequestT = Model::UpdateNamedQueryRequest>
  Model::UpdateNamedQueryOutcomeCallable UpdateNamedQueryCallable(const UpdateNamedQueryRequestT& request) const {
    return SubmitCallable(&AthenaClient::UpdateNamedQuery, request);
  }
 
  template <typename UpdateNamedQueryRequestT = Model::UpdateNamedQueryRequest>
  void UpdateNamedQueryAsync(const UpdateNamedQueryRequestT& request, const UpdateNamedQueryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::UpdateNamedQuery, request, handler, context);
  }
 
  virtual Model::UpdateNotebookOutcome UpdateNotebook(const Model::UpdateNotebookRequest& request) const;
 
  template <typename UpdateNotebookRequestT = Model::UpdateNotebookRequest>
  Model::UpdateNotebookOutcomeCallable UpdateNotebookCallable(const UpdateNotebookRequestT& request) const {
    return SubmitCallable(&AthenaClient::UpdateNotebook, request);
  }
 
  template <typename UpdateNotebookRequestT = Model::UpdateNotebookRequest>
  void UpdateNotebookAsync(const UpdateNotebookRequestT& request, const UpdateNotebookResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::UpdateNotebook, request, handler, context);
  }
 
  virtual Model::UpdateNotebookMetadataOutcome UpdateNotebookMetadata(const Model::UpdateNotebookMetadataRequest& request) const;
 
  template <typename UpdateNotebookMetadataRequestT = Model::UpdateNotebookMetadataRequest>
  Model::UpdateNotebookMetadataOutcomeCallable UpdateNotebookMetadataCallable(const UpdateNotebookMetadataRequestT& request) const {
    return SubmitCallable(&AthenaClient::UpdateNotebookMetadata, request);
  }
 
  template <typename UpdateNotebookMetadataRequestT = Model::UpdateNotebookMetadataRequest>
  void UpdateNotebookMetadataAsync(const UpdateNotebookMetadataRequestT& request,
                                   const UpdateNotebookMetadataResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::UpdateNotebookMetadata, request, handler, context);
  }
 
  virtual Model::UpdatePreparedStatementOutcome UpdatePreparedStatement(const Model::UpdatePreparedStatementRequest& request) const;
 
  template <typename UpdatePreparedStatementRequestT = Model::UpdatePreparedStatementRequest>
  Model::UpdatePreparedStatementOutcomeCallable UpdatePreparedStatementCallable(const UpdatePreparedStatementRequestT& request) const {
    return SubmitCallable(&AthenaClient::UpdatePreparedStatement, request);
  }
 
  template <typename UpdatePreparedStatementRequestT = Model::UpdatePreparedStatementRequest>
  void UpdatePreparedStatementAsync(const UpdatePreparedStatementRequestT& request,
                                    const UpdatePreparedStatementResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::UpdatePreparedStatement, request, handler, context);
  }
 
  virtual Model::UpdateWorkGroupOutcome UpdateWorkGroup(const Model::UpdateWorkGroupRequest& request) const;
 
  template <typename UpdateWorkGroupRequestT = Model::UpdateWorkGroupRequest>
  Model::UpdateWorkGroupOutcomeCallable UpdateWorkGroupCallable(const UpdateWorkGroupRequestT& request) const {
    return SubmitCallable(&AthenaClient::UpdateWorkGroup, request);
  }
 
  template <typename UpdateWorkGroupRequestT = Model::UpdateWorkGroupRequest>
  void UpdateWorkGroupAsync(const UpdateWorkGroupRequestT& request, const UpdateWorkGroupResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AthenaClient::UpdateWorkGroup, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AthenaEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AthenaClient>;
  void init(const AthenaClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AthenaError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  AthenaClientConfiguration m_clientConfiguration;
  std::shared_ptr<AthenaEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Athena
}  // namespace Aws