ElasticsearchServiceClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/es/ElasticsearchServicePaginationBase.h>
#include <aws/es/ElasticsearchServiceServiceClientModel.h>
#include <aws/es/ElasticsearchService_EXPORTS.h>
 
namespace Aws {
namespace ElasticsearchService {
class AWS_ELASTICSEARCHSERVICE_API ElasticsearchServiceClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<ElasticsearchServiceClient>,
      public ElasticsearchServicePaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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