AthenaClient.h

 
#pragma once
#include <aws/athena/Athena_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/athena/AthenaServiceClientModel.h>
 
namespace Aws
{
namespace Athena
{
  class AWS_ATHENA_API AthenaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AthenaEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AthenaClient>;
      void init(const AthenaClientConfiguration& clientConfiguration);
 
      AthenaClientConfiguration m_clientConfiguration;
      std::shared_ptr<AthenaEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Athena
} // namespace Aws