ElasticsearchServiceClient.h

 
#pragma once
#include <aws/es/ElasticsearchService_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/es/ElasticsearchServiceServiceClientModel.h>
 
namespace Aws
{
namespace ElasticsearchService
{
  class AWS_ELASTICSEARCHSERVICE_API ElasticsearchServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ElasticsearchServiceClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ElasticsearchServiceClientConfiguration ClientConfigurationType;
      typedef ElasticsearchServiceEndpointProvider EndpointProviderType;
 
        ElasticsearchServiceClient(const Aws::ElasticsearchService::ElasticsearchServiceClientConfiguration& clientConfiguration = Aws::ElasticsearchService::ElasticsearchServiceClientConfiguration(),
                                   std::shared_ptr<ElasticsearchServiceEndpointProviderBase> endpointProvider = nullptr);
 
        ElasticsearchServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                   std::shared_ptr<ElasticsearchServiceEndpointProviderBase> endpointProvider = nullptr,
                                   const Aws::ElasticsearchService::ElasticsearchServiceClientConfiguration& clientConfiguration = Aws::ElasticsearchService::ElasticsearchServiceClientConfiguration());
 
        ElasticsearchServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                   std::shared_ptr<ElasticsearchServiceEndpointProviderBase> endpointProvider = nullptr,
                                   const Aws::ElasticsearchService::ElasticsearchServiceClientConfiguration& clientConfiguration = Aws::ElasticsearchService::ElasticsearchServiceClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ElasticsearchServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ElasticsearchServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ElasticsearchServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ElasticsearchServiceClient();
 
        virtual Model::AcceptInboundCrossClusterSearchConnectionOutcome AcceptInboundCrossClusterSearchConnection(const Model::AcceptInboundCrossClusterSearchConnectionRequest& request) const;
 
        template<typename AcceptInboundCrossClusterSearchConnectionRequestT = Model::AcceptInboundCrossClusterSearchConnectionRequest>
        Model::AcceptInboundCrossClusterSearchConnectionOutcomeCallable AcceptInboundCrossClusterSearchConnectionCallable(const AcceptInboundCrossClusterSearchConnectionRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::AcceptInboundCrossClusterSearchConnection, request);
        }
 
        template<typename AcceptInboundCrossClusterSearchConnectionRequestT = Model::AcceptInboundCrossClusterSearchConnectionRequest>
        void AcceptInboundCrossClusterSearchConnectionAsync(const AcceptInboundCrossClusterSearchConnectionRequestT& request, const AcceptInboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::AcceptInboundCrossClusterSearchConnection, request, handler, context);
        }
 
        virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const;
 
        template<typename AddTagsRequestT = Model::AddTagsRequest>
        Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::AddTags, request);
        }
 
        template<typename AddTagsRequestT = Model::AddTagsRequest>
        void AddTagsAsync(const AddTagsRequestT& request, const AddTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::AddTags, request, handler, context);
        }
 
        virtual Model::AssociatePackageOutcome AssociatePackage(const Model::AssociatePackageRequest& request) const;
 
        template<typename AssociatePackageRequestT = Model::AssociatePackageRequest>
        Model::AssociatePackageOutcomeCallable AssociatePackageCallable(const AssociatePackageRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::AssociatePackage, request);
        }
 
        template<typename AssociatePackageRequestT = Model::AssociatePackageRequest>
        void AssociatePackageAsync(const AssociatePackageRequestT& request, const AssociatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::AssociatePackage, request, handler, context);
        }
 
        virtual Model::AuthorizeVpcEndpointAccessOutcome AuthorizeVpcEndpointAccess(const Model::AuthorizeVpcEndpointAccessRequest& request) const;
 
        template<typename AuthorizeVpcEndpointAccessRequestT = Model::AuthorizeVpcEndpointAccessRequest>
        Model::AuthorizeVpcEndpointAccessOutcomeCallable AuthorizeVpcEndpointAccessCallable(const AuthorizeVpcEndpointAccessRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::AuthorizeVpcEndpointAccess, request);
        }
 
        template<typename AuthorizeVpcEndpointAccessRequestT = Model::AuthorizeVpcEndpointAccessRequest>
        void AuthorizeVpcEndpointAccessAsync(const AuthorizeVpcEndpointAccessRequestT& request, const AuthorizeVpcEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::AuthorizeVpcEndpointAccess, request, handler, context);
        }
 
        virtual Model::CancelDomainConfigChangeOutcome CancelDomainConfigChange(const Model::CancelDomainConfigChangeRequest& request) const;
 
        template<typename CancelDomainConfigChangeRequestT = Model::CancelDomainConfigChangeRequest>
        Model::CancelDomainConfigChangeOutcomeCallable CancelDomainConfigChangeCallable(const CancelDomainConfigChangeRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::CancelDomainConfigChange, request);
        }
 
        template<typename CancelDomainConfigChangeRequestT = Model::CancelDomainConfigChangeRequest>
        void CancelDomainConfigChangeAsync(const CancelDomainConfigChangeRequestT& request, const CancelDomainConfigChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::CancelDomainConfigChange, request, handler, context);
        }
 
        virtual Model::CancelElasticsearchServiceSoftwareUpdateOutcome CancelElasticsearchServiceSoftwareUpdate(const Model::CancelElasticsearchServiceSoftwareUpdateRequest& request) const;
 
        template<typename CancelElasticsearchServiceSoftwareUpdateRequestT = Model::CancelElasticsearchServiceSoftwareUpdateRequest>
        Model::CancelElasticsearchServiceSoftwareUpdateOutcomeCallable CancelElasticsearchServiceSoftwareUpdateCallable(const CancelElasticsearchServiceSoftwareUpdateRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::CancelElasticsearchServiceSoftwareUpdate, request);
        }
 
        template<typename CancelElasticsearchServiceSoftwareUpdateRequestT = Model::CancelElasticsearchServiceSoftwareUpdateRequest>
        void CancelElasticsearchServiceSoftwareUpdateAsync(const CancelElasticsearchServiceSoftwareUpdateRequestT& request, const CancelElasticsearchServiceSoftwareUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::CancelElasticsearchServiceSoftwareUpdate, request, handler, context);
        }
 
        virtual Model::CreateElasticsearchDomainOutcome CreateElasticsearchDomain(const Model::CreateElasticsearchDomainRequest& request) const;
 
        template<typename CreateElasticsearchDomainRequestT = Model::CreateElasticsearchDomainRequest>
        Model::CreateElasticsearchDomainOutcomeCallable CreateElasticsearchDomainCallable(const CreateElasticsearchDomainRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::CreateElasticsearchDomain, request);
        }
 
        template<typename CreateElasticsearchDomainRequestT = Model::CreateElasticsearchDomainRequest>
        void CreateElasticsearchDomainAsync(const CreateElasticsearchDomainRequestT& request, const CreateElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::CreateElasticsearchDomain, request, handler, context);
        }
 
        virtual Model::CreateOutboundCrossClusterSearchConnectionOutcome CreateOutboundCrossClusterSearchConnection(const Model::CreateOutboundCrossClusterSearchConnectionRequest& request) const;
 
        template<typename CreateOutboundCrossClusterSearchConnectionRequestT = Model::CreateOutboundCrossClusterSearchConnectionRequest>
        Model::CreateOutboundCrossClusterSearchConnectionOutcomeCallable CreateOutboundCrossClusterSearchConnectionCallable(const CreateOutboundCrossClusterSearchConnectionRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::CreateOutboundCrossClusterSearchConnection, request);
        }
 
        template<typename CreateOutboundCrossClusterSearchConnectionRequestT = Model::CreateOutboundCrossClusterSearchConnectionRequest>
        void CreateOutboundCrossClusterSearchConnectionAsync(const CreateOutboundCrossClusterSearchConnectionRequestT& request, const CreateOutboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::CreateOutboundCrossClusterSearchConnection, request, handler, context);
        }
 
        virtual Model::CreatePackageOutcome CreatePackage(const Model::CreatePackageRequest& request) const;
 
        template<typename CreatePackageRequestT = Model::CreatePackageRequest>
        Model::CreatePackageOutcomeCallable CreatePackageCallable(const CreatePackageRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::CreatePackage, request);
        }
 
        template<typename CreatePackageRequestT = Model::CreatePackageRequest>
        void CreatePackageAsync(const CreatePackageRequestT& request, const CreatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::CreatePackage, request, handler, context);
        }
 
        virtual Model::CreateVpcEndpointOutcome CreateVpcEndpoint(const Model::CreateVpcEndpointRequest& request) const;
 
        template<typename CreateVpcEndpointRequestT = Model::CreateVpcEndpointRequest>
        Model::CreateVpcEndpointOutcomeCallable CreateVpcEndpointCallable(const CreateVpcEndpointRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::CreateVpcEndpoint, request);
        }
 
        template<typename CreateVpcEndpointRequestT = Model::CreateVpcEndpointRequest>
        void CreateVpcEndpointAsync(const CreateVpcEndpointRequestT& request, const CreateVpcEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::CreateVpcEndpoint, request, handler, context);
        }
 
        virtual Model::DeleteElasticsearchDomainOutcome DeleteElasticsearchDomain(const Model::DeleteElasticsearchDomainRequest& request) const;
 
        template<typename DeleteElasticsearchDomainRequestT = Model::DeleteElasticsearchDomainRequest>
        Model::DeleteElasticsearchDomainOutcomeCallable DeleteElasticsearchDomainCallable(const DeleteElasticsearchDomainRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DeleteElasticsearchDomain, request);
        }
 
        template<typename DeleteElasticsearchDomainRequestT = Model::DeleteElasticsearchDomainRequest>
        void DeleteElasticsearchDomainAsync(const DeleteElasticsearchDomainRequestT& request, const DeleteElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DeleteElasticsearchDomain, request, handler, context);
        }
 
        virtual Model::DeleteElasticsearchServiceRoleOutcome DeleteElasticsearchServiceRole(const Model::DeleteElasticsearchServiceRoleRequest& request = {}) const;
 
        template<typename DeleteElasticsearchServiceRoleRequestT = Model::DeleteElasticsearchServiceRoleRequest>
        Model::DeleteElasticsearchServiceRoleOutcomeCallable DeleteElasticsearchServiceRoleCallable(const DeleteElasticsearchServiceRoleRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DeleteElasticsearchServiceRole, request);
        }
 
        template<typename DeleteElasticsearchServiceRoleRequestT = Model::DeleteElasticsearchServiceRoleRequest>
        void DeleteElasticsearchServiceRoleAsync(const DeleteElasticsearchServiceRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteElasticsearchServiceRoleRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DeleteElasticsearchServiceRole, request, handler, context);
        }
 
        virtual Model::DeleteInboundCrossClusterSearchConnectionOutcome DeleteInboundCrossClusterSearchConnection(const Model::DeleteInboundCrossClusterSearchConnectionRequest& request) const;
 
        template<typename DeleteInboundCrossClusterSearchConnectionRequestT = Model::DeleteInboundCrossClusterSearchConnectionRequest>
        Model::DeleteInboundCrossClusterSearchConnectionOutcomeCallable DeleteInboundCrossClusterSearchConnectionCallable(const DeleteInboundCrossClusterSearchConnectionRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DeleteInboundCrossClusterSearchConnection, request);
        }
 
        template<typename DeleteInboundCrossClusterSearchConnectionRequestT = Model::DeleteInboundCrossClusterSearchConnectionRequest>
        void DeleteInboundCrossClusterSearchConnectionAsync(const DeleteInboundCrossClusterSearchConnectionRequestT& request, const DeleteInboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DeleteInboundCrossClusterSearchConnection, request, handler, context);
        }
 
        virtual Model::DeleteOutboundCrossClusterSearchConnectionOutcome DeleteOutboundCrossClusterSearchConnection(const Model::DeleteOutboundCrossClusterSearchConnectionRequest& request) const;
 
        template<typename DeleteOutboundCrossClusterSearchConnectionRequestT = Model::DeleteOutboundCrossClusterSearchConnectionRequest>
        Model::DeleteOutboundCrossClusterSearchConnectionOutcomeCallable DeleteOutboundCrossClusterSearchConnectionCallable(const DeleteOutboundCrossClusterSearchConnectionRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DeleteOutboundCrossClusterSearchConnection, request);
        }
 
        template<typename DeleteOutboundCrossClusterSearchConnectionRequestT = Model::DeleteOutboundCrossClusterSearchConnectionRequest>
        void DeleteOutboundCrossClusterSearchConnectionAsync(const DeleteOutboundCrossClusterSearchConnectionRequestT& request, const DeleteOutboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DeleteOutboundCrossClusterSearchConnection, request, handler, context);
        }
 
        virtual Model::DeletePackageOutcome DeletePackage(const Model::DeletePackageRequest& request) const;
 
        template<typename DeletePackageRequestT = Model::DeletePackageRequest>
        Model::DeletePackageOutcomeCallable DeletePackageCallable(const DeletePackageRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DeletePackage, request);
        }
 
        template<typename DeletePackageRequestT = Model::DeletePackageRequest>
        void DeletePackageAsync(const DeletePackageRequestT& request, const DeletePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DeletePackage, request, handler, context);
        }
 
        virtual Model::DeleteVpcEndpointOutcome DeleteVpcEndpoint(const Model::DeleteVpcEndpointRequest& request) const;
 
        template<typename DeleteVpcEndpointRequestT = Model::DeleteVpcEndpointRequest>
        Model::DeleteVpcEndpointOutcomeCallable DeleteVpcEndpointCallable(const DeleteVpcEndpointRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DeleteVpcEndpoint, request);
        }
 
        template<typename DeleteVpcEndpointRequestT = Model::DeleteVpcEndpointRequest>
        void DeleteVpcEndpointAsync(const DeleteVpcEndpointRequestT& request, const DeleteVpcEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DeleteVpcEndpoint, request, handler, context);
        }
 
        virtual Model::DescribeDomainAutoTunesOutcome DescribeDomainAutoTunes(const Model::DescribeDomainAutoTunesRequest& request) const;
 
        template<typename DescribeDomainAutoTunesRequestT = Model::DescribeDomainAutoTunesRequest>
        Model::DescribeDomainAutoTunesOutcomeCallable DescribeDomainAutoTunesCallable(const DescribeDomainAutoTunesRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeDomainAutoTunes, request);
        }
 
        template<typename DescribeDomainAutoTunesRequestT = Model::DescribeDomainAutoTunesRequest>
        void DescribeDomainAutoTunesAsync(const DescribeDomainAutoTunesRequestT& request, const DescribeDomainAutoTunesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeDomainAutoTunes, request, handler, context);
        }
 
        virtual Model::DescribeDomainChangeProgressOutcome DescribeDomainChangeProgress(const Model::DescribeDomainChangeProgressRequest& request) const;
 
        template<typename DescribeDomainChangeProgressRequestT = Model::DescribeDomainChangeProgressRequest>
        Model::DescribeDomainChangeProgressOutcomeCallable DescribeDomainChangeProgressCallable(const DescribeDomainChangeProgressRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeDomainChangeProgress, request);
        }
 
        template<typename DescribeDomainChangeProgressRequestT = Model::DescribeDomainChangeProgressRequest>
        void DescribeDomainChangeProgressAsync(const DescribeDomainChangeProgressRequestT& request, const DescribeDomainChangeProgressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeDomainChangeProgress, request, handler, context);
        }
 
        virtual Model::DescribeElasticsearchDomainOutcome DescribeElasticsearchDomain(const Model::DescribeElasticsearchDomainRequest& request) const;
 
        template<typename DescribeElasticsearchDomainRequestT = Model::DescribeElasticsearchDomainRequest>
        Model::DescribeElasticsearchDomainOutcomeCallable DescribeElasticsearchDomainCallable(const DescribeElasticsearchDomainRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeElasticsearchDomain, request);
        }
 
        template<typename DescribeElasticsearchDomainRequestT = Model::DescribeElasticsearchDomainRequest>
        void DescribeElasticsearchDomainAsync(const DescribeElasticsearchDomainRequestT& request, const DescribeElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeElasticsearchDomain, request, handler, context);
        }
 
        virtual Model::DescribeElasticsearchDomainConfigOutcome DescribeElasticsearchDomainConfig(const Model::DescribeElasticsearchDomainConfigRequest& request) const;
 
        template<typename DescribeElasticsearchDomainConfigRequestT = Model::DescribeElasticsearchDomainConfigRequest>
        Model::DescribeElasticsearchDomainConfigOutcomeCallable DescribeElasticsearchDomainConfigCallable(const DescribeElasticsearchDomainConfigRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeElasticsearchDomainConfig, request);
        }
 
        template<typename DescribeElasticsearchDomainConfigRequestT = Model::DescribeElasticsearchDomainConfigRequest>
        void DescribeElasticsearchDomainConfigAsync(const DescribeElasticsearchDomainConfigRequestT& request, const DescribeElasticsearchDomainConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeElasticsearchDomainConfig, request, handler, context);
        }
 
        virtual Model::DescribeElasticsearchDomainsOutcome DescribeElasticsearchDomains(const Model::DescribeElasticsearchDomainsRequest& request) const;
 
        template<typename DescribeElasticsearchDomainsRequestT = Model::DescribeElasticsearchDomainsRequest>
        Model::DescribeElasticsearchDomainsOutcomeCallable DescribeElasticsearchDomainsCallable(const DescribeElasticsearchDomainsRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeElasticsearchDomains, request);
        }
 
        template<typename DescribeElasticsearchDomainsRequestT = Model::DescribeElasticsearchDomainsRequest>
        void DescribeElasticsearchDomainsAsync(const DescribeElasticsearchDomainsRequestT& request, const DescribeElasticsearchDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeElasticsearchDomains, request, handler, context);
        }
 
        virtual Model::DescribeElasticsearchInstanceTypeLimitsOutcome DescribeElasticsearchInstanceTypeLimits(const Model::DescribeElasticsearchInstanceTypeLimitsRequest& request) const;
 
        template<typename DescribeElasticsearchInstanceTypeLimitsRequestT = Model::DescribeElasticsearchInstanceTypeLimitsRequest>
        Model::DescribeElasticsearchInstanceTypeLimitsOutcomeCallable DescribeElasticsearchInstanceTypeLimitsCallable(const DescribeElasticsearchInstanceTypeLimitsRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeElasticsearchInstanceTypeLimits, request);
        }
 
        template<typename DescribeElasticsearchInstanceTypeLimitsRequestT = Model::DescribeElasticsearchInstanceTypeLimitsRequest>
        void DescribeElasticsearchInstanceTypeLimitsAsync(const DescribeElasticsearchInstanceTypeLimitsRequestT& request, const DescribeElasticsearchInstanceTypeLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeElasticsearchInstanceTypeLimits, request, handler, context);
        }
 
        virtual Model::DescribeInboundCrossClusterSearchConnectionsOutcome DescribeInboundCrossClusterSearchConnections(const Model::DescribeInboundCrossClusterSearchConnectionsRequest& request = {}) const;
 
        template<typename DescribeInboundCrossClusterSearchConnectionsRequestT = Model::DescribeInboundCrossClusterSearchConnectionsRequest>
        Model::DescribeInboundCrossClusterSearchConnectionsOutcomeCallable DescribeInboundCrossClusterSearchConnectionsCallable(const DescribeInboundCrossClusterSearchConnectionsRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeInboundCrossClusterSearchConnections, request);
        }
 
        template<typename DescribeInboundCrossClusterSearchConnectionsRequestT = Model::DescribeInboundCrossClusterSearchConnectionsRequest>
        void DescribeInboundCrossClusterSearchConnectionsAsync(const DescribeInboundCrossClusterSearchConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeInboundCrossClusterSearchConnectionsRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeInboundCrossClusterSearchConnections, request, handler, context);
        }
 
        virtual Model::DescribeOutboundCrossClusterSearchConnectionsOutcome DescribeOutboundCrossClusterSearchConnections(const Model::DescribeOutboundCrossClusterSearchConnectionsRequest& request = {}) const;
 
        template<typename DescribeOutboundCrossClusterSearchConnectionsRequestT = Model::DescribeOutboundCrossClusterSearchConnectionsRequest>
        Model::DescribeOutboundCrossClusterSearchConnectionsOutcomeCallable DescribeOutboundCrossClusterSearchConnectionsCallable(const DescribeOutboundCrossClusterSearchConnectionsRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeOutboundCrossClusterSearchConnections, request);
        }
 
        template<typename DescribeOutboundCrossClusterSearchConnectionsRequestT = Model::DescribeOutboundCrossClusterSearchConnectionsRequest>
        void DescribeOutboundCrossClusterSearchConnectionsAsync(const DescribeOutboundCrossClusterSearchConnectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeOutboundCrossClusterSearchConnectionsRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeOutboundCrossClusterSearchConnections, request, handler, context);
        }
 
        virtual Model::DescribePackagesOutcome DescribePackages(const Model::DescribePackagesRequest& request = {}) const;
 
        template<typename DescribePackagesRequestT = Model::DescribePackagesRequest>
        Model::DescribePackagesOutcomeCallable DescribePackagesCallable(const DescribePackagesRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribePackages, request);
        }
 
        template<typename DescribePackagesRequestT = Model::DescribePackagesRequest>
        void DescribePackagesAsync(const DescribePackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribePackagesRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribePackages, request, handler, context);
        }
 
        virtual Model::DescribeReservedElasticsearchInstanceOfferingsOutcome DescribeReservedElasticsearchInstanceOfferings(const Model::DescribeReservedElasticsearchInstanceOfferingsRequest& request = {}) const;
 
        template<typename DescribeReservedElasticsearchInstanceOfferingsRequestT = Model::DescribeReservedElasticsearchInstanceOfferingsRequest>
        Model::DescribeReservedElasticsearchInstanceOfferingsOutcomeCallable DescribeReservedElasticsearchInstanceOfferingsCallable(const DescribeReservedElasticsearchInstanceOfferingsRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeReservedElasticsearchInstanceOfferings, request);
        }
 
        template<typename DescribeReservedElasticsearchInstanceOfferingsRequestT = Model::DescribeReservedElasticsearchInstanceOfferingsRequest>
        void DescribeReservedElasticsearchInstanceOfferingsAsync(const DescribeReservedElasticsearchInstanceOfferingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReservedElasticsearchInstanceOfferingsRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeReservedElasticsearchInstanceOfferings, request, handler, context);
        }
 
        virtual Model::DescribeReservedElasticsearchInstancesOutcome DescribeReservedElasticsearchInstances(const Model::DescribeReservedElasticsearchInstancesRequest& request = {}) const;
 
        template<typename DescribeReservedElasticsearchInstancesRequestT = Model::DescribeReservedElasticsearchInstancesRequest>
        Model::DescribeReservedElasticsearchInstancesOutcomeCallable DescribeReservedElasticsearchInstancesCallable(const DescribeReservedElasticsearchInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeReservedElasticsearchInstances, request);
        }
 
        template<typename DescribeReservedElasticsearchInstancesRequestT = Model::DescribeReservedElasticsearchInstancesRequest>
        void DescribeReservedElasticsearchInstancesAsync(const DescribeReservedElasticsearchInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeReservedElasticsearchInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeReservedElasticsearchInstances, request, handler, context);
        }
 
        virtual Model::DescribeVpcEndpointsOutcome DescribeVpcEndpoints(const Model::DescribeVpcEndpointsRequest& request) const;
 
        template<typename DescribeVpcEndpointsRequestT = Model::DescribeVpcEndpointsRequest>
        Model::DescribeVpcEndpointsOutcomeCallable DescribeVpcEndpointsCallable(const DescribeVpcEndpointsRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DescribeVpcEndpoints, request);
        }
 
        template<typename DescribeVpcEndpointsRequestT = Model::DescribeVpcEndpointsRequest>
        void DescribeVpcEndpointsAsync(const DescribeVpcEndpointsRequestT& request, const DescribeVpcEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DescribeVpcEndpoints, request, handler, context);
        }
 
        virtual Model::DissociatePackageOutcome DissociatePackage(const Model::DissociatePackageRequest& request) const;
 
        template<typename DissociatePackageRequestT = Model::DissociatePackageRequest>
        Model::DissociatePackageOutcomeCallable DissociatePackageCallable(const DissociatePackageRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::DissociatePackage, request);
        }
 
        template<typename DissociatePackageRequestT = Model::DissociatePackageRequest>
        void DissociatePackageAsync(const DissociatePackageRequestT& request, const DissociatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::DissociatePackage, request, handler, context);
        }
 
        virtual Model::GetCompatibleElasticsearchVersionsOutcome GetCompatibleElasticsearchVersions(const Model::GetCompatibleElasticsearchVersionsRequest& request = {}) const;
 
        template<typename GetCompatibleElasticsearchVersionsRequestT = Model::GetCompatibleElasticsearchVersionsRequest>
        Model::GetCompatibleElasticsearchVersionsOutcomeCallable GetCompatibleElasticsearchVersionsCallable(const GetCompatibleElasticsearchVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::GetCompatibleElasticsearchVersions, request);
        }
 
        template<typename GetCompatibleElasticsearchVersionsRequestT = Model::GetCompatibleElasticsearchVersionsRequest>
        void GetCompatibleElasticsearchVersionsAsync(const GetCompatibleElasticsearchVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetCompatibleElasticsearchVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::GetCompatibleElasticsearchVersions, request, handler, context);
        }
 
        virtual Model::GetPackageVersionHistoryOutcome GetPackageVersionHistory(const Model::GetPackageVersionHistoryRequest& request) const;
 
        template<typename GetPackageVersionHistoryRequestT = Model::GetPackageVersionHistoryRequest>
        Model::GetPackageVersionHistoryOutcomeCallable GetPackageVersionHistoryCallable(const GetPackageVersionHistoryRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::GetPackageVersionHistory, request);
        }
 
        template<typename GetPackageVersionHistoryRequestT = Model::GetPackageVersionHistoryRequest>
        void GetPackageVersionHistoryAsync(const GetPackageVersionHistoryRequestT& request, const GetPackageVersionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::GetPackageVersionHistory, request, handler, context);
        }
 
        virtual Model::GetUpgradeHistoryOutcome GetUpgradeHistory(const Model::GetUpgradeHistoryRequest& request) const;
 
        template<typename GetUpgradeHistoryRequestT = Model::GetUpgradeHistoryRequest>
        Model::GetUpgradeHistoryOutcomeCallable GetUpgradeHistoryCallable(const GetUpgradeHistoryRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::GetUpgradeHistory, request);
        }
 
        template<typename GetUpgradeHistoryRequestT = Model::GetUpgradeHistoryRequest>
        void GetUpgradeHistoryAsync(const GetUpgradeHistoryRequestT& request, const GetUpgradeHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::GetUpgradeHistory, request, handler, context);
        }
 
        virtual Model::GetUpgradeStatusOutcome GetUpgradeStatus(const Model::GetUpgradeStatusRequest& request) const;
 
        template<typename GetUpgradeStatusRequestT = Model::GetUpgradeStatusRequest>
        Model::GetUpgradeStatusOutcomeCallable GetUpgradeStatusCallable(const GetUpgradeStatusRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::GetUpgradeStatus, request);
        }
 
        template<typename GetUpgradeStatusRequestT = Model::GetUpgradeStatusRequest>
        void GetUpgradeStatusAsync(const GetUpgradeStatusRequestT& request, const GetUpgradeStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::GetUpgradeStatus, request, handler, context);
        }
 
        virtual Model::ListDomainNamesOutcome ListDomainNames(const Model::ListDomainNamesRequest& request = {}) const;
 
        template<typename ListDomainNamesRequestT = Model::ListDomainNamesRequest>
        Model::ListDomainNamesOutcomeCallable ListDomainNamesCallable(const ListDomainNamesRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::ListDomainNames, request);
        }
 
        template<typename ListDomainNamesRequestT = Model::ListDomainNamesRequest>
        void ListDomainNamesAsync(const ListDomainNamesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDomainNamesRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::ListDomainNames, request, handler, context);
        }
 
        virtual Model::ListDomainsForPackageOutcome ListDomainsForPackage(const Model::ListDomainsForPackageRequest& request) const;
 
        template<typename ListDomainsForPackageRequestT = Model::ListDomainsForPackageRequest>
        Model::ListDomainsForPackageOutcomeCallable ListDomainsForPackageCallable(const ListDomainsForPackageRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::ListDomainsForPackage, request);
        }
 
        template<typename ListDomainsForPackageRequestT = Model::ListDomainsForPackageRequest>
        void ListDomainsForPackageAsync(const ListDomainsForPackageRequestT& request, const ListDomainsForPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::ListDomainsForPackage, request, handler, context);
        }
 
        virtual Model::ListElasticsearchInstanceTypesOutcome ListElasticsearchInstanceTypes(const Model::ListElasticsearchInstanceTypesRequest& request) const;
 
        template<typename ListElasticsearchInstanceTypesRequestT = Model::ListElasticsearchInstanceTypesRequest>
        Model::ListElasticsearchInstanceTypesOutcomeCallable ListElasticsearchInstanceTypesCallable(const ListElasticsearchInstanceTypesRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::ListElasticsearchInstanceTypes, request);
        }
 
        template<typename ListElasticsearchInstanceTypesRequestT = Model::ListElasticsearchInstanceTypesRequest>
        void ListElasticsearchInstanceTypesAsync(const ListElasticsearchInstanceTypesRequestT& request, const ListElasticsearchInstanceTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::ListElasticsearchInstanceTypes, request, handler, context);
        }
 
        virtual Model::ListElasticsearchVersionsOutcome ListElasticsearchVersions(const Model::ListElasticsearchVersionsRequest& request = {}) const;
 
        template<typename ListElasticsearchVersionsRequestT = Model::ListElasticsearchVersionsRequest>
        Model::ListElasticsearchVersionsOutcomeCallable ListElasticsearchVersionsCallable(const ListElasticsearchVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::ListElasticsearchVersions, request);
        }
 
        template<typename ListElasticsearchVersionsRequestT = Model::ListElasticsearchVersionsRequest>
        void ListElasticsearchVersionsAsync(const ListElasticsearchVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListElasticsearchVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::ListElasticsearchVersions, request, handler, context);
        }
 
        virtual Model::ListPackagesForDomainOutcome ListPackagesForDomain(const Model::ListPackagesForDomainRequest& request) const;
 
        template<typename ListPackagesForDomainRequestT = Model::ListPackagesForDomainRequest>
        Model::ListPackagesForDomainOutcomeCallable ListPackagesForDomainCallable(const ListPackagesForDomainRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::ListPackagesForDomain, request);
        }
 
        template<typename ListPackagesForDomainRequestT = Model::ListPackagesForDomainRequest>
        void ListPackagesForDomainAsync(const ListPackagesForDomainRequestT& request, const ListPackagesForDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::ListPackagesForDomain, request, handler, context);
        }
 
        virtual Model::ListTagsOutcome ListTags(const Model::ListTagsRequest& request) const;
 
        template<typename ListTagsRequestT = Model::ListTagsRequest>
        Model::ListTagsOutcomeCallable ListTagsCallable(const ListTagsRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::ListTags, request);
        }
 
        template<typename ListTagsRequestT = Model::ListTagsRequest>
        void ListTagsAsync(const ListTagsRequestT& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::ListTags, request, handler, context);
        }
 
        virtual Model::ListVpcEndpointAccessOutcome ListVpcEndpointAccess(const Model::ListVpcEndpointAccessRequest& request) const;
 
        template<typename ListVpcEndpointAccessRequestT = Model::ListVpcEndpointAccessRequest>
        Model::ListVpcEndpointAccessOutcomeCallable ListVpcEndpointAccessCallable(const ListVpcEndpointAccessRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::ListVpcEndpointAccess, request);
        }
 
        template<typename ListVpcEndpointAccessRequestT = Model::ListVpcEndpointAccessRequest>
        void ListVpcEndpointAccessAsync(const ListVpcEndpointAccessRequestT& request, const ListVpcEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::ListVpcEndpointAccess, request, handler, context);
        }
 
        virtual Model::ListVpcEndpointsOutcome ListVpcEndpoints(const Model::ListVpcEndpointsRequest& request = {}) const;
 
        template<typename ListVpcEndpointsRequestT = Model::ListVpcEndpointsRequest>
        Model::ListVpcEndpointsOutcomeCallable ListVpcEndpointsCallable(const ListVpcEndpointsRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::ListVpcEndpoints, request);
        }
 
        template<typename ListVpcEndpointsRequestT = Model::ListVpcEndpointsRequest>
        void ListVpcEndpointsAsync(const ListVpcEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVpcEndpointsRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::ListVpcEndpoints, request, handler, context);
        }
 
        virtual Model::ListVpcEndpointsForDomainOutcome ListVpcEndpointsForDomain(const Model::ListVpcEndpointsForDomainRequest& request) const;
 
        template<typename ListVpcEndpointsForDomainRequestT = Model::ListVpcEndpointsForDomainRequest>
        Model::ListVpcEndpointsForDomainOutcomeCallable ListVpcEndpointsForDomainCallable(const ListVpcEndpointsForDomainRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::ListVpcEndpointsForDomain, request);
        }
 
        template<typename ListVpcEndpointsForDomainRequestT = Model::ListVpcEndpointsForDomainRequest>
        void ListVpcEndpointsForDomainAsync(const ListVpcEndpointsForDomainRequestT& request, const ListVpcEndpointsForDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::ListVpcEndpointsForDomain, request, handler, context);
        }
 
        virtual Model::PurchaseReservedElasticsearchInstanceOfferingOutcome PurchaseReservedElasticsearchInstanceOffering(const Model::PurchaseReservedElasticsearchInstanceOfferingRequest& request) const;
 
        template<typename PurchaseReservedElasticsearchInstanceOfferingRequestT = Model::PurchaseReservedElasticsearchInstanceOfferingRequest>
        Model::PurchaseReservedElasticsearchInstanceOfferingOutcomeCallable PurchaseReservedElasticsearchInstanceOfferingCallable(const PurchaseReservedElasticsearchInstanceOfferingRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::PurchaseReservedElasticsearchInstanceOffering, request);
        }
 
        template<typename PurchaseReservedElasticsearchInstanceOfferingRequestT = Model::PurchaseReservedElasticsearchInstanceOfferingRequest>
        void PurchaseReservedElasticsearchInstanceOfferingAsync(const PurchaseReservedElasticsearchInstanceOfferingRequestT& request, const PurchaseReservedElasticsearchInstanceOfferingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::PurchaseReservedElasticsearchInstanceOffering, request, handler, context);
        }
 
        virtual Model::RejectInboundCrossClusterSearchConnectionOutcome RejectInboundCrossClusterSearchConnection(const Model::RejectInboundCrossClusterSearchConnectionRequest& request) const;
 
        template<typename RejectInboundCrossClusterSearchConnectionRequestT = Model::RejectInboundCrossClusterSearchConnectionRequest>
        Model::RejectInboundCrossClusterSearchConnectionOutcomeCallable RejectInboundCrossClusterSearchConnectionCallable(const RejectInboundCrossClusterSearchConnectionRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::RejectInboundCrossClusterSearchConnection, request);
        }
 
        template<typename RejectInboundCrossClusterSearchConnectionRequestT = Model::RejectInboundCrossClusterSearchConnectionRequest>
        void RejectInboundCrossClusterSearchConnectionAsync(const RejectInboundCrossClusterSearchConnectionRequestT& request, const RejectInboundCrossClusterSearchConnectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::RejectInboundCrossClusterSearchConnection, request, handler, context);
        }
 
        virtual Model::RemoveTagsOutcome RemoveTags(const Model::RemoveTagsRequest& request) const;
 
        template<typename RemoveTagsRequestT = Model::RemoveTagsRequest>
        Model::RemoveTagsOutcomeCallable RemoveTagsCallable(const RemoveTagsRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::RemoveTags, request);
        }
 
        template<typename RemoveTagsRequestT = Model::RemoveTagsRequest>
        void RemoveTagsAsync(const RemoveTagsRequestT& request, const RemoveTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::RemoveTags, request, handler, context);
        }
 
        virtual Model::RevokeVpcEndpointAccessOutcome RevokeVpcEndpointAccess(const Model::RevokeVpcEndpointAccessRequest& request) const;
 
        template<typename RevokeVpcEndpointAccessRequestT = Model::RevokeVpcEndpointAccessRequest>
        Model::RevokeVpcEndpointAccessOutcomeCallable RevokeVpcEndpointAccessCallable(const RevokeVpcEndpointAccessRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::RevokeVpcEndpointAccess, request);
        }
 
        template<typename RevokeVpcEndpointAccessRequestT = Model::RevokeVpcEndpointAccessRequest>
        void RevokeVpcEndpointAccessAsync(const RevokeVpcEndpointAccessRequestT& request, const RevokeVpcEndpointAccessResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::RevokeVpcEndpointAccess, request, handler, context);
        }
 
        virtual Model::StartElasticsearchServiceSoftwareUpdateOutcome StartElasticsearchServiceSoftwareUpdate(const Model::StartElasticsearchServiceSoftwareUpdateRequest& request) const;
 
        template<typename StartElasticsearchServiceSoftwareUpdateRequestT = Model::StartElasticsearchServiceSoftwareUpdateRequest>
        Model::StartElasticsearchServiceSoftwareUpdateOutcomeCallable StartElasticsearchServiceSoftwareUpdateCallable(const StartElasticsearchServiceSoftwareUpdateRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::StartElasticsearchServiceSoftwareUpdate, request);
        }
 
        template<typename StartElasticsearchServiceSoftwareUpdateRequestT = Model::StartElasticsearchServiceSoftwareUpdateRequest>
        void StartElasticsearchServiceSoftwareUpdateAsync(const StartElasticsearchServiceSoftwareUpdateRequestT& request, const StartElasticsearchServiceSoftwareUpdateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::StartElasticsearchServiceSoftwareUpdate, request, handler, context);
        }
 
        virtual Model::UpdateElasticsearchDomainConfigOutcome UpdateElasticsearchDomainConfig(const Model::UpdateElasticsearchDomainConfigRequest& request) const;
 
        template<typename UpdateElasticsearchDomainConfigRequestT = Model::UpdateElasticsearchDomainConfigRequest>
        Model::UpdateElasticsearchDomainConfigOutcomeCallable UpdateElasticsearchDomainConfigCallable(const UpdateElasticsearchDomainConfigRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::UpdateElasticsearchDomainConfig, request);
        }
 
        template<typename UpdateElasticsearchDomainConfigRequestT = Model::UpdateElasticsearchDomainConfigRequest>
        void UpdateElasticsearchDomainConfigAsync(const UpdateElasticsearchDomainConfigRequestT& request, const UpdateElasticsearchDomainConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::UpdateElasticsearchDomainConfig, request, handler, context);
        }
 
        virtual Model::UpdatePackageOutcome UpdatePackage(const Model::UpdatePackageRequest& request) const;
 
        template<typename UpdatePackageRequestT = Model::UpdatePackageRequest>
        Model::UpdatePackageOutcomeCallable UpdatePackageCallable(const UpdatePackageRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::UpdatePackage, request);
        }
 
        template<typename UpdatePackageRequestT = Model::UpdatePackageRequest>
        void UpdatePackageAsync(const UpdatePackageRequestT& request, const UpdatePackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::UpdatePackage, request, handler, context);
        }
 
        virtual Model::UpdateVpcEndpointOutcome UpdateVpcEndpoint(const Model::UpdateVpcEndpointRequest& request) const;
 
        template<typename UpdateVpcEndpointRequestT = Model::UpdateVpcEndpointRequest>
        Model::UpdateVpcEndpointOutcomeCallable UpdateVpcEndpointCallable(const UpdateVpcEndpointRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::UpdateVpcEndpoint, request);
        }
 
        template<typename UpdateVpcEndpointRequestT = Model::UpdateVpcEndpointRequest>
        void UpdateVpcEndpointAsync(const UpdateVpcEndpointRequestT& request, const UpdateVpcEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::UpdateVpcEndpoint, request, handler, context);
        }
 
        virtual Model::UpgradeElasticsearchDomainOutcome UpgradeElasticsearchDomain(const Model::UpgradeElasticsearchDomainRequest& request) const;
 
        template<typename UpgradeElasticsearchDomainRequestT = Model::UpgradeElasticsearchDomainRequest>
        Model::UpgradeElasticsearchDomainOutcomeCallable UpgradeElasticsearchDomainCallable(const UpgradeElasticsearchDomainRequestT& request) const
        {
            return SubmitCallable(&ElasticsearchServiceClient::UpgradeElasticsearchDomain, request);
        }
 
        template<typename UpgradeElasticsearchDomainRequestT = Model::UpgradeElasticsearchDomainRequest>
        void UpgradeElasticsearchDomainAsync(const UpgradeElasticsearchDomainRequestT& request, const UpgradeElasticsearchDomainResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticsearchServiceClient::UpgradeElasticsearchDomain, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ElasticsearchServiceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ElasticsearchServiceClient>;
      void init(const ElasticsearchServiceClientConfiguration& clientConfiguration);
 
      ElasticsearchServiceClientConfiguration m_clientConfiguration;
      std::shared_ptr<ElasticsearchServiceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ElasticsearchService
} // namespace Aws