OpenSearchServiceClient.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/opensearch/OpenSearchServicePaginationBase.h>
#include <aws/opensearch/OpenSearchServiceServiceClientModel.h>
#include <aws/opensearch/OpenSearchServiceWaiter.h>
#include <aws/opensearch/OpenSearchService_EXPORTS.h>
 
namespace Aws {
namespace OpenSearchService {
class AWS_OPENSEARCHSERVICE_API OpenSearchServiceClient : public Aws::Client::AWSJsonClient,
                                                          public Aws::Client::ClientWithAsyncTemplateMethods<OpenSearchServiceClient>,
                                                          public OpenSearchServicePaginationBase<OpenSearchServiceClient>,
                                                          public OpenSearchServiceWaiter<OpenSearchServiceClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef OpenSearchServiceClientConfiguration ClientConfigurationType;
  typedef OpenSearchServiceEndpointProvider EndpointProviderType;
 
  OpenSearchServiceClient(const Aws::OpenSearchService::OpenSearchServiceClientConfiguration& clientConfiguration =
                              Aws::OpenSearchService::OpenSearchServiceClientConfiguration(),
                          std::shared_ptr<OpenSearchServiceEndpointProviderBase> endpointProvider = nullptr);
 
  OpenSearchServiceClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<OpenSearchServiceEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::OpenSearchService::OpenSearchServiceClientConfiguration& clientConfiguration =
                              Aws::OpenSearchService::OpenSearchServiceClientConfiguration());
 
  OpenSearchServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<OpenSearchServiceEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::OpenSearchService::OpenSearchServiceClientConfiguration& clientConfiguration =
                              Aws::OpenSearchService::OpenSearchServiceClientConfiguration());
 
  /* Legacy constructors due deprecation */
  OpenSearchServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  OpenSearchServiceClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  OpenSearchServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~OpenSearchServiceClient();
 
  virtual Model::AcceptInboundConnectionOutcome AcceptInboundConnection(const Model::AcceptInboundConnectionRequest& request) const;
 
  template <typename AcceptInboundConnectionRequestT = Model::AcceptInboundConnectionRequest>
  Model::AcceptInboundConnectionOutcomeCallable AcceptInboundConnectionCallable(const AcceptInboundConnectionRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::AcceptInboundConnection, request);
  }
 
  template <typename AcceptInboundConnectionRequestT = Model::AcceptInboundConnectionRequest>
  void AcceptInboundConnectionAsync(const AcceptInboundConnectionRequestT& request,
                                    const AcceptInboundConnectionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::AcceptInboundConnection, request, handler, context);
  }
 
  virtual Model::AddDataSourceOutcome AddDataSource(const Model::AddDataSourceRequest& request) const;
 
  template <typename AddDataSourceRequestT = Model::AddDataSourceRequest>
  Model::AddDataSourceOutcomeCallable AddDataSourceCallable(const AddDataSourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::AddDataSource, request);
  }
 
  template <typename AddDataSourceRequestT = Model::AddDataSourceRequest>
  void AddDataSourceAsync(const AddDataSourceRequestT& request, const AddDataSourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::AddDataSource, request, handler, context);
  }
 
  virtual Model::AddDirectQueryDataSourceOutcome AddDirectQueryDataSource(const Model::AddDirectQueryDataSourceRequest& request) const;
 
  template <typename AddDirectQueryDataSourceRequestT = Model::AddDirectQueryDataSourceRequest>
  Model::AddDirectQueryDataSourceOutcomeCallable AddDirectQueryDataSourceCallable(const AddDirectQueryDataSourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::AddDirectQueryDataSource, request);
  }
 
  template <typename AddDirectQueryDataSourceRequestT = Model::AddDirectQueryDataSourceRequest>
  void AddDirectQueryDataSourceAsync(const AddDirectQueryDataSourceRequestT& request,
                                     const AddDirectQueryDataSourceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::AddDirectQueryDataSource, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::AssociatePackage, request, handler, context);
  }
 
  virtual Model::AssociatePackagesOutcome AssociatePackages(const Model::AssociatePackagesRequest& request) const;
 
  template <typename AssociatePackagesRequestT = Model::AssociatePackagesRequest>
  Model::AssociatePackagesOutcomeCallable AssociatePackagesCallable(const AssociatePackagesRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::AssociatePackages, request);
  }
 
  template <typename AssociatePackagesRequestT = Model::AssociatePackagesRequest>
  void AssociatePackagesAsync(const AssociatePackagesRequestT& request, const AssociatePackagesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::AssociatePackages, request, handler, context);
  }
 
  virtual Model::AttachDataSourceOutcome AttachDataSource(const Model::AttachDataSourceRequest& request) const;
 
  template <typename AttachDataSourceRequestT = Model::AttachDataSourceRequest>
  Model::AttachDataSourceOutcomeCallable AttachDataSourceCallable(const AttachDataSourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::AttachDataSource, request);
  }
 
  template <typename AttachDataSourceRequestT = Model::AttachDataSourceRequest>
  void AttachDataSourceAsync(const AttachDataSourceRequestT& request, const AttachDataSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::AttachDataSource, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::CancelDomainConfigChange, request, handler, context);
  }
 
  virtual Model::CancelServiceSoftwareUpdateOutcome CancelServiceSoftwareUpdate(
      const Model::CancelServiceSoftwareUpdateRequest& request) const;
 
  template <typename CancelServiceSoftwareUpdateRequestT = Model::CancelServiceSoftwareUpdateRequest>
  Model::CancelServiceSoftwareUpdateOutcomeCallable CancelServiceSoftwareUpdateCallable(
      const CancelServiceSoftwareUpdateRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::CancelServiceSoftwareUpdate, request);
  }
 
  template <typename CancelServiceSoftwareUpdateRequestT = Model::CancelServiceSoftwareUpdateRequest>
  void CancelServiceSoftwareUpdateAsync(const CancelServiceSoftwareUpdateRequestT& request,
                                        const CancelServiceSoftwareUpdateResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::CancelServiceSoftwareUpdate, request, handler, context);
  }
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const;
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::CreateDomain, request);
  }
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::CreateDomain, request, handler, context);
  }
 
  virtual Model::CreateIndexOutcome CreateIndex(const Model::CreateIndexRequest& request) const;
 
  template <typename CreateIndexRequestT = Model::CreateIndexRequest>
  Model::CreateIndexOutcomeCallable CreateIndexCallable(const CreateIndexRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::CreateIndex, request);
  }
 
  template <typename CreateIndexRequestT = Model::CreateIndexRequest>
  void CreateIndexAsync(const CreateIndexRequestT& request, const CreateIndexResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::CreateIndex, request, handler, context);
  }
 
  virtual Model::CreateOutboundConnectionOutcome CreateOutboundConnection(const Model::CreateOutboundConnectionRequest& request) const;
 
  template <typename CreateOutboundConnectionRequestT = Model::CreateOutboundConnectionRequest>
  Model::CreateOutboundConnectionOutcomeCallable CreateOutboundConnectionCallable(const CreateOutboundConnectionRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::CreateOutboundConnection, request);
  }
 
  template <typename CreateOutboundConnectionRequestT = Model::CreateOutboundConnectionRequest>
  void CreateOutboundConnectionAsync(const CreateOutboundConnectionRequestT& request,
                                     const CreateOutboundConnectionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::CreateOutboundConnection, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::CreateVpcEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteDataSourceOutcome DeleteDataSource(const Model::DeleteDataSourceRequest& request) const;
 
  template <typename DeleteDataSourceRequestT = Model::DeleteDataSourceRequest>
  Model::DeleteDataSourceOutcomeCallable DeleteDataSourceCallable(const DeleteDataSourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DeleteDataSource, request);
  }
 
  template <typename DeleteDataSourceRequestT = Model::DeleteDataSourceRequest>
  void DeleteDataSourceAsync(const DeleteDataSourceRequestT& request, const DeleteDataSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DeleteDataSource, request, handler, context);
  }
 
  virtual Model::DeleteDirectQueryDataSourceOutcome DeleteDirectQueryDataSource(
      const Model::DeleteDirectQueryDataSourceRequest& request) const;
 
  template <typename DeleteDirectQueryDataSourceRequestT = Model::DeleteDirectQueryDataSourceRequest>
  Model::DeleteDirectQueryDataSourceOutcomeCallable DeleteDirectQueryDataSourceCallable(
      const DeleteDirectQueryDataSourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DeleteDirectQueryDataSource, request);
  }
 
  template <typename DeleteDirectQueryDataSourceRequestT = Model::DeleteDirectQueryDataSourceRequest>
  void DeleteDirectQueryDataSourceAsync(const DeleteDirectQueryDataSourceRequestT& request,
                                        const DeleteDirectQueryDataSourceResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DeleteDirectQueryDataSource, request, handler, context);
  }
 
  virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DeleteDomain, request);
  }
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DeleteDomain, request, handler, context);
  }
 
  virtual Model::DeleteInboundConnectionOutcome DeleteInboundConnection(const Model::DeleteInboundConnectionRequest& request) const;
 
  template <typename DeleteInboundConnectionRequestT = Model::DeleteInboundConnectionRequest>
  Model::DeleteInboundConnectionOutcomeCallable DeleteInboundConnectionCallable(const DeleteInboundConnectionRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DeleteInboundConnection, request);
  }
 
  template <typename DeleteInboundConnectionRequestT = Model::DeleteInboundConnectionRequest>
  void DeleteInboundConnectionAsync(const DeleteInboundConnectionRequestT& request,
                                    const DeleteInboundConnectionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DeleteInboundConnection, request, handler, context);
  }
 
  virtual Model::DeleteIndexOutcome DeleteIndex(const Model::DeleteIndexRequest& request) const;
 
  template <typename DeleteIndexRequestT = Model::DeleteIndexRequest>
  Model::DeleteIndexOutcomeCallable DeleteIndexCallable(const DeleteIndexRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DeleteIndex, request);
  }
 
  template <typename DeleteIndexRequestT = Model::DeleteIndexRequest>
  void DeleteIndexAsync(const DeleteIndexRequestT& request, const DeleteIndexResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DeleteIndex, request, handler, context);
  }
 
  virtual Model::DeleteOutboundConnectionOutcome DeleteOutboundConnection(const Model::DeleteOutboundConnectionRequest& request) const;
 
  template <typename DeleteOutboundConnectionRequestT = Model::DeleteOutboundConnectionRequest>
  Model::DeleteOutboundConnectionOutcomeCallable DeleteOutboundConnectionCallable(const DeleteOutboundConnectionRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DeleteOutboundConnection, request);
  }
 
  template <typename DeleteOutboundConnectionRequestT = Model::DeleteOutboundConnectionRequest>
  void DeleteOutboundConnectionAsync(const DeleteOutboundConnectionRequestT& request,
                                     const DeleteOutboundConnectionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DeleteOutboundConnection, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::DeleteVpcEndpoint, request, handler, context);
  }
 
  virtual Model::DeregisterCapabilityOutcome DeregisterCapability(const Model::DeregisterCapabilityRequest& request) const;
 
  template <typename DeregisterCapabilityRequestT = Model::DeregisterCapabilityRequest>
  Model::DeregisterCapabilityOutcomeCallable DeregisterCapabilityCallable(const DeregisterCapabilityRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DeregisterCapability, request);
  }
 
  template <typename DeregisterCapabilityRequestT = Model::DeregisterCapabilityRequest>
  void DeregisterCapabilityAsync(const DeregisterCapabilityRequestT& request, const DeregisterCapabilityResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DeregisterCapability, request, handler, context);
  }
 
  virtual Model::DescribeDataSourceAttachmentOutcome DescribeDataSourceAttachment(
      const Model::DescribeDataSourceAttachmentRequest& request) const;
 
  template <typename DescribeDataSourceAttachmentRequestT = Model::DescribeDataSourceAttachmentRequest>
  Model::DescribeDataSourceAttachmentOutcomeCallable DescribeDataSourceAttachmentCallable(
      const DescribeDataSourceAttachmentRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeDataSourceAttachment, request);
  }
 
  template <typename DescribeDataSourceAttachmentRequestT = Model::DescribeDataSourceAttachmentRequest>
  void DescribeDataSourceAttachmentAsync(const DescribeDataSourceAttachmentRequestT& request,
                                         const DescribeDataSourceAttachmentResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeDataSourceAttachment, request, handler, context);
  }
 
  virtual Model::DescribeDomainOutcome DescribeDomain(const Model::DescribeDomainRequest& request) const;
 
  template <typename DescribeDomainRequestT = Model::DescribeDomainRequest>
  Model::DescribeDomainOutcomeCallable DescribeDomainCallable(const DescribeDomainRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeDomain, request);
  }
 
  template <typename DescribeDomainRequestT = Model::DescribeDomainRequest>
  void DescribeDomainAsync(const DescribeDomainRequestT& request, const DescribeDomainResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeDomain, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::DescribeDomainChangeProgress, request, handler, context);
  }
 
  virtual Model::DescribeDomainConfigOutcome DescribeDomainConfig(const Model::DescribeDomainConfigRequest& request) const;
 
  template <typename DescribeDomainConfigRequestT = Model::DescribeDomainConfigRequest>
  Model::DescribeDomainConfigOutcomeCallable DescribeDomainConfigCallable(const DescribeDomainConfigRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeDomainConfig, request);
  }
 
  template <typename DescribeDomainConfigRequestT = Model::DescribeDomainConfigRequest>
  void DescribeDomainConfigAsync(const DescribeDomainConfigRequestT& request, const DescribeDomainConfigResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeDomainConfig, request, handler, context);
  }
 
  virtual Model::DescribeDomainHealthOutcome DescribeDomainHealth(const Model::DescribeDomainHealthRequest& request) const;
 
  template <typename DescribeDomainHealthRequestT = Model::DescribeDomainHealthRequest>
  Model::DescribeDomainHealthOutcomeCallable DescribeDomainHealthCallable(const DescribeDomainHealthRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeDomainHealth, request);
  }
 
  template <typename DescribeDomainHealthRequestT = Model::DescribeDomainHealthRequest>
  void DescribeDomainHealthAsync(const DescribeDomainHealthRequestT& request, const DescribeDomainHealthResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeDomainHealth, request, handler, context);
  }
 
  virtual Model::DescribeDomainNodesOutcome DescribeDomainNodes(const Model::DescribeDomainNodesRequest& request) const;
 
  template <typename DescribeDomainNodesRequestT = Model::DescribeDomainNodesRequest>
  Model::DescribeDomainNodesOutcomeCallable DescribeDomainNodesCallable(const DescribeDomainNodesRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeDomainNodes, request);
  }
 
  template <typename DescribeDomainNodesRequestT = Model::DescribeDomainNodesRequest>
  void DescribeDomainNodesAsync(const DescribeDomainNodesRequestT& request, const DescribeDomainNodesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeDomainNodes, request, handler, context);
  }
 
  virtual Model::DescribeDomainsOutcome DescribeDomains(const Model::DescribeDomainsRequest& request) const;
 
  template <typename DescribeDomainsRequestT = Model::DescribeDomainsRequest>
  Model::DescribeDomainsOutcomeCallable DescribeDomainsCallable(const DescribeDomainsRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeDomains, request);
  }
 
  template <typename DescribeDomainsRequestT = Model::DescribeDomainsRequest>
  void DescribeDomainsAsync(const DescribeDomainsRequestT& request, const DescribeDomainsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeDomains, request, handler, context);
  }
 
  virtual Model::DescribeDryRunProgressOutcome DescribeDryRunProgress(const Model::DescribeDryRunProgressRequest& request) const;
 
  template <typename DescribeDryRunProgressRequestT = Model::DescribeDryRunProgressRequest>
  Model::DescribeDryRunProgressOutcomeCallable DescribeDryRunProgressCallable(const DescribeDryRunProgressRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeDryRunProgress, request);
  }
 
  template <typename DescribeDryRunProgressRequestT = Model::DescribeDryRunProgressRequest>
  void DescribeDryRunProgressAsync(const DescribeDryRunProgressRequestT& request,
                                   const DescribeDryRunProgressResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeDryRunProgress, request, handler, context);
  }
 
  virtual Model::DescribeInboundConnectionsOutcome DescribeInboundConnections(
      const Model::DescribeInboundConnectionsRequest& request = {}) const;
 
  template <typename DescribeInboundConnectionsRequestT = Model::DescribeInboundConnectionsRequest>
  Model::DescribeInboundConnectionsOutcomeCallable DescribeInboundConnectionsCallable(
      const DescribeInboundConnectionsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeInboundConnections, request);
  }
 
  template <typename DescribeInboundConnectionsRequestT = Model::DescribeInboundConnectionsRequest>
  void DescribeInboundConnectionsAsync(const DescribeInboundConnectionsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeInboundConnectionsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeInboundConnections, request, handler, context);
  }
 
  virtual Model::DescribeInsightDetailsOutcome DescribeInsightDetails(const Model::DescribeInsightDetailsRequest& request) const;
 
  template <typename DescribeInsightDetailsRequestT = Model::DescribeInsightDetailsRequest>
  Model::DescribeInsightDetailsOutcomeCallable DescribeInsightDetailsCallable(const DescribeInsightDetailsRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeInsightDetails, request);
  }
 
  template <typename DescribeInsightDetailsRequestT = Model::DescribeInsightDetailsRequest>
  void DescribeInsightDetailsAsync(const DescribeInsightDetailsRequestT& request,
                                   const DescribeInsightDetailsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeInsightDetails, request, handler, context);
  }
 
  virtual Model::DescribeInstanceTypeLimitsOutcome DescribeInstanceTypeLimits(
      const Model::DescribeInstanceTypeLimitsRequest& request) const;
 
  template <typename DescribeInstanceTypeLimitsRequestT = Model::DescribeInstanceTypeLimitsRequest>
  Model::DescribeInstanceTypeLimitsOutcomeCallable DescribeInstanceTypeLimitsCallable(
      const DescribeInstanceTypeLimitsRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeInstanceTypeLimits, request);
  }
 
  template <typename DescribeInstanceTypeLimitsRequestT = Model::DescribeInstanceTypeLimitsRequest>
  void DescribeInstanceTypeLimitsAsync(const DescribeInstanceTypeLimitsRequestT& request,
                                       const DescribeInstanceTypeLimitsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeInstanceTypeLimits, request, handler, context);
  }
 
  virtual Model::DescribeOutboundConnectionsOutcome DescribeOutboundConnections(
      const Model::DescribeOutboundConnectionsRequest& request = {}) const;
 
  template <typename DescribeOutboundConnectionsRequestT = Model::DescribeOutboundConnectionsRequest>
  Model::DescribeOutboundConnectionsOutcomeCallable DescribeOutboundConnectionsCallable(
      const DescribeOutboundConnectionsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeOutboundConnections, request);
  }
 
  template <typename DescribeOutboundConnectionsRequestT = Model::DescribeOutboundConnectionsRequest>
  void DescribeOutboundConnectionsAsync(const DescribeOutboundConnectionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DescribeOutboundConnectionsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeOutboundConnections, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::DescribePackages, request, handler, context);
  }
 
  virtual Model::DescribeReservedInstanceOfferingsOutcome DescribeReservedInstanceOfferings(
      const Model::DescribeReservedInstanceOfferingsRequest& request = {}) const;
 
  template <typename DescribeReservedInstanceOfferingsRequestT = Model::DescribeReservedInstanceOfferingsRequest>
  Model::DescribeReservedInstanceOfferingsOutcomeCallable DescribeReservedInstanceOfferingsCallable(
      const DescribeReservedInstanceOfferingsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeReservedInstanceOfferings, request);
  }
 
  template <typename DescribeReservedInstanceOfferingsRequestT = Model::DescribeReservedInstanceOfferingsRequest>
  void DescribeReservedInstanceOfferingsAsync(const DescribeReservedInstanceOfferingsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const DescribeReservedInstanceOfferingsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeReservedInstanceOfferings, request, handler, context);
  }
 
  virtual Model::DescribeReservedInstancesOutcome DescribeReservedInstances(
      const Model::DescribeReservedInstancesRequest& request = {}) const;
 
  template <typename DescribeReservedInstancesRequestT = Model::DescribeReservedInstancesRequest>
  Model::DescribeReservedInstancesOutcomeCallable DescribeReservedInstancesCallable(
      const DescribeReservedInstancesRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServiceClient::DescribeReservedInstances, request);
  }
 
  template <typename DescribeReservedInstancesRequestT = Model::DescribeReservedInstancesRequest>
  void DescribeReservedInstancesAsync(const DescribeReservedInstancesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const DescribeReservedInstancesRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServiceClient::DescribeReservedInstances, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::DescribeVpcEndpoints, request, handler, context);
  }
 
  virtual Model::DetachDataSourceOutcome DetachDataSource(const Model::DetachDataSourceRequest& request) const;
 
  template <typename DetachDataSourceRequestT = Model::DetachDataSourceRequest>
  Model::DetachDataSourceOutcomeCallable DetachDataSourceCallable(const DetachDataSourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DetachDataSource, request);
  }
 
  template <typename DetachDataSourceRequestT = Model::DetachDataSourceRequest>
  void DetachDataSourceAsync(const DetachDataSourceRequestT& request, const DetachDataSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DetachDataSource, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::DissociatePackage, request, handler, context);
  }
 
  virtual Model::DissociatePackagesOutcome DissociatePackages(const Model::DissociatePackagesRequest& request) const;
 
  template <typename DissociatePackagesRequestT = Model::DissociatePackagesRequest>
  Model::DissociatePackagesOutcomeCallable DissociatePackagesCallable(const DissociatePackagesRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::DissociatePackages, request);
  }
 
  template <typename DissociatePackagesRequestT = Model::DissociatePackagesRequest>
  void DissociatePackagesAsync(const DissociatePackagesRequestT& request, const DissociatePackagesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::DissociatePackages, request, handler, context);
  }
 
  virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request) const;
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::GetApplication, request);
  }
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  void GetApplicationAsync(const GetApplicationRequestT& request, const GetApplicationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::GetApplication, request, handler, context);
  }
 
  virtual Model::GetCapabilityOutcome GetCapability(const Model::GetCapabilityRequest& request) const;
 
  template <typename GetCapabilityRequestT = Model::GetCapabilityRequest>
  Model::GetCapabilityOutcomeCallable GetCapabilityCallable(const GetCapabilityRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::GetCapability, request);
  }
 
  template <typename GetCapabilityRequestT = Model::GetCapabilityRequest>
  void GetCapabilityAsync(const GetCapabilityRequestT& request, const GetCapabilityResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::GetCapability, request, handler, context);
  }
 
  virtual Model::GetCompatibleVersionsOutcome GetCompatibleVersions(const Model::GetCompatibleVersionsRequest& request = {}) const;
 
  template <typename GetCompatibleVersionsRequestT = Model::GetCompatibleVersionsRequest>
  Model::GetCompatibleVersionsOutcomeCallable GetCompatibleVersionsCallable(const GetCompatibleVersionsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServiceClient::GetCompatibleVersions, request);
  }
 
  template <typename GetCompatibleVersionsRequestT = Model::GetCompatibleVersionsRequest>
  void GetCompatibleVersionsAsync(const GetCompatibleVersionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const GetCompatibleVersionsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServiceClient::GetCompatibleVersions, request, handler, context);
  }
 
  virtual Model::GetDataSourceOutcome GetDataSource(const Model::GetDataSourceRequest& request) const;
 
  template <typename GetDataSourceRequestT = Model::GetDataSourceRequest>
  Model::GetDataSourceOutcomeCallable GetDataSourceCallable(const GetDataSourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::GetDataSource, request);
  }
 
  template <typename GetDataSourceRequestT = Model::GetDataSourceRequest>
  void GetDataSourceAsync(const GetDataSourceRequestT& request, const GetDataSourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::GetDataSource, request, handler, context);
  }
 
  virtual Model::GetDefaultApplicationSettingOutcome GetDefaultApplicationSetting(
      const Model::GetDefaultApplicationSettingRequest& request = {}) const;
 
  template <typename GetDefaultApplicationSettingRequestT = Model::GetDefaultApplicationSettingRequest>
  Model::GetDefaultApplicationSettingOutcomeCallable GetDefaultApplicationSettingCallable(
      const GetDefaultApplicationSettingRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServiceClient::GetDefaultApplicationSetting, request);
  }
 
  template <typename GetDefaultApplicationSettingRequestT = Model::GetDefaultApplicationSettingRequest>
  void GetDefaultApplicationSettingAsync(const GetDefaultApplicationSettingResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetDefaultApplicationSettingRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServiceClient::GetDefaultApplicationSetting, request, handler, context);
  }
 
  virtual Model::GetDirectQueryDataSourceOutcome GetDirectQueryDataSource(const Model::GetDirectQueryDataSourceRequest& request) const;
 
  template <typename GetDirectQueryDataSourceRequestT = Model::GetDirectQueryDataSourceRequest>
  Model::GetDirectQueryDataSourceOutcomeCallable GetDirectQueryDataSourceCallable(const GetDirectQueryDataSourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::GetDirectQueryDataSource, request);
  }
 
  template <typename GetDirectQueryDataSourceRequestT = Model::GetDirectQueryDataSourceRequest>
  void GetDirectQueryDataSourceAsync(const GetDirectQueryDataSourceRequestT& request,
                                     const GetDirectQueryDataSourceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::GetDirectQueryDataSource, request, handler, context);
  }
 
  virtual Model::GetDomainMaintenanceStatusOutcome GetDomainMaintenanceStatus(
      const Model::GetDomainMaintenanceStatusRequest& request) const;
 
  template <typename GetDomainMaintenanceStatusRequestT = Model::GetDomainMaintenanceStatusRequest>
  Model::GetDomainMaintenanceStatusOutcomeCallable GetDomainMaintenanceStatusCallable(
      const GetDomainMaintenanceStatusRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::GetDomainMaintenanceStatus, request);
  }
 
  template <typename GetDomainMaintenanceStatusRequestT = Model::GetDomainMaintenanceStatusRequest>
  void GetDomainMaintenanceStatusAsync(const GetDomainMaintenanceStatusRequestT& request,
                                       const GetDomainMaintenanceStatusResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::GetDomainMaintenanceStatus, request, handler, context);
  }
 
  virtual Model::GetIndexOutcome GetIndex(const Model::GetIndexRequest& request) const;
 
  template <typename GetIndexRequestT = Model::GetIndexRequest>
  Model::GetIndexOutcomeCallable GetIndexCallable(const GetIndexRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::GetIndex, request);
  }
 
  template <typename GetIndexRequestT = Model::GetIndexRequest>
  void GetIndexAsync(const GetIndexRequestT& request, const GetIndexResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::GetIndex, request, handler, context);
  }
 
  virtual Model::GetMigrationOutcome GetMigration(const Model::GetMigrationRequest& request) const;
 
  template <typename GetMigrationRequestT = Model::GetMigrationRequest>
  Model::GetMigrationOutcomeCallable GetMigrationCallable(const GetMigrationRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::GetMigration, request);
  }
 
  template <typename GetMigrationRequestT = Model::GetMigrationRequest>
  void GetMigrationAsync(const GetMigrationRequestT& request, const GetMigrationResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::GetMigration, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::GetUpgradeStatus, request, handler, context);
  }
 
  virtual Model::InsightFeedbackOutcome InsightFeedback(const Model::InsightFeedbackRequest& request) const;
 
  template <typename InsightFeedbackRequestT = Model::InsightFeedbackRequest>
  Model::InsightFeedbackOutcomeCallable InsightFeedbackCallable(const InsightFeedbackRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::InsightFeedback, request);
  }
 
  template <typename InsightFeedbackRequestT = Model::InsightFeedbackRequest>
  void InsightFeedbackAsync(const InsightFeedbackRequestT& request, const InsightFeedbackResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::InsightFeedback, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServiceClient::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListApplicationsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServiceClient::ListApplications, request, handler, context);
  }
 
  virtual Model::ListDataSourceAttachmentsOutcome ListDataSourceAttachments(const Model::ListDataSourceAttachmentsRequest& request) const;
 
  template <typename ListDataSourceAttachmentsRequestT = Model::ListDataSourceAttachmentsRequest>
  Model::ListDataSourceAttachmentsOutcomeCallable ListDataSourceAttachmentsCallable(
      const ListDataSourceAttachmentsRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::ListDataSourceAttachments, request);
  }
 
  template <typename ListDataSourceAttachmentsRequestT = Model::ListDataSourceAttachmentsRequest>
  void ListDataSourceAttachmentsAsync(const ListDataSourceAttachmentsRequestT& request,
                                      const ListDataSourceAttachmentsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::ListDataSourceAttachments, request, handler, context);
  }
 
  virtual Model::ListDataSourcesOutcome ListDataSources(const Model::ListDataSourcesRequest& request) const;
 
  template <typename ListDataSourcesRequestT = Model::ListDataSourcesRequest>
  Model::ListDataSourcesOutcomeCallable ListDataSourcesCallable(const ListDataSourcesRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::ListDataSources, request);
  }
 
  template <typename ListDataSourcesRequestT = Model::ListDataSourcesRequest>
  void ListDataSourcesAsync(const ListDataSourcesRequestT& request, const ListDataSourcesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::ListDataSources, request, handler, context);
  }
 
  virtual Model::ListDirectQueryDataSourcesOutcome ListDirectQueryDataSources(
      const Model::ListDirectQueryDataSourcesRequest& request = {}) const;
 
  template <typename ListDirectQueryDataSourcesRequestT = Model::ListDirectQueryDataSourcesRequest>
  Model::ListDirectQueryDataSourcesOutcomeCallable ListDirectQueryDataSourcesCallable(
      const ListDirectQueryDataSourcesRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServiceClient::ListDirectQueryDataSources, request);
  }
 
  template <typename ListDirectQueryDataSourcesRequestT = Model::ListDirectQueryDataSourcesRequest>
  void ListDirectQueryDataSourcesAsync(const ListDirectQueryDataSourcesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListDirectQueryDataSourcesRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServiceClient::ListDirectQueryDataSources, request, handler, context);
  }
 
  virtual Model::ListDomainMaintenancesOutcome ListDomainMaintenances(const Model::ListDomainMaintenancesRequest& request) const;
 
  template <typename ListDomainMaintenancesRequestT = Model::ListDomainMaintenancesRequest>
  Model::ListDomainMaintenancesOutcomeCallable ListDomainMaintenancesCallable(const ListDomainMaintenancesRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::ListDomainMaintenances, request);
  }
 
  template <typename ListDomainMaintenancesRequestT = Model::ListDomainMaintenancesRequest>
  void ListDomainMaintenancesAsync(const ListDomainMaintenancesRequestT& request,
                                   const ListDomainMaintenancesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::ListDomainMaintenances, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::ListDomainsForPackage, request, handler, context);
  }
 
  virtual Model::ListInsightsOutcome ListInsights(const Model::ListInsightsRequest& request) const;
 
  template <typename ListInsightsRequestT = Model::ListInsightsRequest>
  Model::ListInsightsOutcomeCallable ListInsightsCallable(const ListInsightsRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::ListInsights, request);
  }
 
  template <typename ListInsightsRequestT = Model::ListInsightsRequest>
  void ListInsightsAsync(const ListInsightsRequestT& request, const ListInsightsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::ListInsights, request, handler, context);
  }
 
  virtual Model::ListInstanceTypeDetailsOutcome ListInstanceTypeDetails(const Model::ListInstanceTypeDetailsRequest& request) const;
 
  template <typename ListInstanceTypeDetailsRequestT = Model::ListInstanceTypeDetailsRequest>
  Model::ListInstanceTypeDetailsOutcomeCallable ListInstanceTypeDetailsCallable(const ListInstanceTypeDetailsRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::ListInstanceTypeDetails, request);
  }
 
  template <typename ListInstanceTypeDetailsRequestT = Model::ListInstanceTypeDetailsRequest>
  void ListInstanceTypeDetailsAsync(const ListInstanceTypeDetailsRequestT& request,
                                    const ListInstanceTypeDetailsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::ListInstanceTypeDetails, request, handler, context);
  }
 
  virtual Model::ListMigrationsOutcome ListMigrations(const Model::ListMigrationsRequest& request) const;
 
  template <typename ListMigrationsRequestT = Model::ListMigrationsRequest>
  Model::ListMigrationsOutcomeCallable ListMigrationsCallable(const ListMigrationsRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::ListMigrations, request);
  }
 
  template <typename ListMigrationsRequestT = Model::ListMigrationsRequest>
  void ListMigrationsAsync(const ListMigrationsRequestT& request, const ListMigrationsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::ListMigrations, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::ListPackagesForDomain, request, handler, context);
  }
 
  virtual Model::ListScheduledActionsOutcome ListScheduledActions(const Model::ListScheduledActionsRequest& request) const;
 
  template <typename ListScheduledActionsRequestT = Model::ListScheduledActionsRequest>
  Model::ListScheduledActionsOutcomeCallable ListScheduledActionsCallable(const ListScheduledActionsRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::ListScheduledActions, request);
  }
 
  template <typename ListScheduledActionsRequestT = Model::ListScheduledActionsRequest>
  void ListScheduledActionsAsync(const ListScheduledActionsRequestT& request, const ListScheduledActionsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::ListScheduledActions, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::ListTags, request, handler, context);
  }
 
  virtual Model::ListVersionsOutcome ListVersions(const Model::ListVersionsRequest& request = {}) const;
 
  template <typename ListVersionsRequestT = Model::ListVersionsRequest>
  Model::ListVersionsOutcomeCallable ListVersionsCallable(const ListVersionsRequestT& request = {}) const {
    return SubmitCallable(&OpenSearchServiceClient::ListVersions, request);
  }
 
  template <typename ListVersionsRequestT = Model::ListVersionsRequest>
  void ListVersionsAsync(const ListVersionsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListVersionsRequestT& request = {}) const {
    return SubmitAsync(&OpenSearchServiceClient::ListVersions, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::ListVpcEndpointsForDomain, request, handler, context);
  }
 
  virtual Model::PurchaseReservedInstanceOfferingOutcome PurchaseReservedInstanceOffering(
      const Model::PurchaseReservedInstanceOfferingRequest& request) const;
 
  template <typename PurchaseReservedInstanceOfferingRequestT = Model::PurchaseReservedInstanceOfferingRequest>
  Model::PurchaseReservedInstanceOfferingOutcomeCallable PurchaseReservedInstanceOfferingCallable(
      const PurchaseReservedInstanceOfferingRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::PurchaseReservedInstanceOffering, request);
  }
 
  template <typename PurchaseReservedInstanceOfferingRequestT = Model::PurchaseReservedInstanceOfferingRequest>
  void PurchaseReservedInstanceOfferingAsync(const PurchaseReservedInstanceOfferingRequestT& request,
                                             const PurchaseReservedInstanceOfferingResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::PurchaseReservedInstanceOffering, request, handler, context);
  }
 
  virtual Model::PutDefaultApplicationSettingOutcome PutDefaultApplicationSetting(
      const Model::PutDefaultApplicationSettingRequest& request) const;
 
  template <typename PutDefaultApplicationSettingRequestT = Model::PutDefaultApplicationSettingRequest>
  Model::PutDefaultApplicationSettingOutcomeCallable PutDefaultApplicationSettingCallable(
      const PutDefaultApplicationSettingRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::PutDefaultApplicationSetting, request);
  }
 
  template <typename PutDefaultApplicationSettingRequestT = Model::PutDefaultApplicationSettingRequest>
  void PutDefaultApplicationSettingAsync(const PutDefaultApplicationSettingRequestT& request,
                                         const PutDefaultApplicationSettingResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::PutDefaultApplicationSetting, request, handler, context);
  }
 
  virtual Model::RegisterCapabilityOutcome RegisterCapability(const Model::RegisterCapabilityRequest& request) const;
 
  template <typename RegisterCapabilityRequestT = Model::RegisterCapabilityRequest>
  Model::RegisterCapabilityOutcomeCallable RegisterCapabilityCallable(const RegisterCapabilityRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::RegisterCapability, request);
  }
 
  template <typename RegisterCapabilityRequestT = Model::RegisterCapabilityRequest>
  void RegisterCapabilityAsync(const RegisterCapabilityRequestT& request, const RegisterCapabilityResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::RegisterCapability, request, handler, context);
  }
 
  virtual Model::RejectInboundConnectionOutcome RejectInboundConnection(const Model::RejectInboundConnectionRequest& request) const;
 
  template <typename RejectInboundConnectionRequestT = Model::RejectInboundConnectionRequest>
  Model::RejectInboundConnectionOutcomeCallable RejectInboundConnectionCallable(const RejectInboundConnectionRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::RejectInboundConnection, request);
  }
 
  template <typename RejectInboundConnectionRequestT = Model::RejectInboundConnectionRequest>
  void RejectInboundConnectionAsync(const RejectInboundConnectionRequestT& request,
                                    const RejectInboundConnectionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::RejectInboundConnection, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::RevokeVpcEndpointAccess, request, handler, context);
  }
 
  virtual Model::RollbackServiceSoftwareUpdateOutcome RollbackServiceSoftwareUpdate(
      const Model::RollbackServiceSoftwareUpdateRequest& request) const;
 
  template <typename RollbackServiceSoftwareUpdateRequestT = Model::RollbackServiceSoftwareUpdateRequest>
  Model::RollbackServiceSoftwareUpdateOutcomeCallable RollbackServiceSoftwareUpdateCallable(
      const RollbackServiceSoftwareUpdateRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::RollbackServiceSoftwareUpdate, request);
  }
 
  template <typename RollbackServiceSoftwareUpdateRequestT = Model::RollbackServiceSoftwareUpdateRequest>
  void RollbackServiceSoftwareUpdateAsync(const RollbackServiceSoftwareUpdateRequestT& request,
                                          const RollbackServiceSoftwareUpdateResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::RollbackServiceSoftwareUpdate, request, handler, context);
  }
 
  virtual Model::StartDomainMaintenanceOutcome StartDomainMaintenance(const Model::StartDomainMaintenanceRequest& request) const;
 
  template <typename StartDomainMaintenanceRequestT = Model::StartDomainMaintenanceRequest>
  Model::StartDomainMaintenanceOutcomeCallable StartDomainMaintenanceCallable(const StartDomainMaintenanceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::StartDomainMaintenance, request);
  }
 
  template <typename StartDomainMaintenanceRequestT = Model::StartDomainMaintenanceRequest>
  void StartDomainMaintenanceAsync(const StartDomainMaintenanceRequestT& request,
                                   const StartDomainMaintenanceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::StartDomainMaintenance, request, handler, context);
  }
 
  virtual Model::StartMigrationOutcome StartMigration(const Model::StartMigrationRequest& request) const;
 
  template <typename StartMigrationRequestT = Model::StartMigrationRequest>
  Model::StartMigrationOutcomeCallable StartMigrationCallable(const StartMigrationRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::StartMigration, request);
  }
 
  template <typename StartMigrationRequestT = Model::StartMigrationRequest>
  void StartMigrationAsync(const StartMigrationRequestT& request, const StartMigrationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::StartMigration, request, handler, context);
  }
 
  virtual Model::StartServiceSoftwareUpdateOutcome StartServiceSoftwareUpdate(
      const Model::StartServiceSoftwareUpdateRequest& request) const;
 
  template <typename StartServiceSoftwareUpdateRequestT = Model::StartServiceSoftwareUpdateRequest>
  Model::StartServiceSoftwareUpdateOutcomeCallable StartServiceSoftwareUpdateCallable(
      const StartServiceSoftwareUpdateRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::StartServiceSoftwareUpdate, request);
  }
 
  template <typename StartServiceSoftwareUpdateRequestT = Model::StartServiceSoftwareUpdateRequest>
  void StartServiceSoftwareUpdateAsync(const StartServiceSoftwareUpdateRequestT& request,
                                       const StartServiceSoftwareUpdateResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::StartServiceSoftwareUpdate, request, handler, context);
  }
 
  virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::UpdateApplication, request);
  }
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateDataSourceOutcome UpdateDataSource(const Model::UpdateDataSourceRequest& request) const;
 
  template <typename UpdateDataSourceRequestT = Model::UpdateDataSourceRequest>
  Model::UpdateDataSourceOutcomeCallable UpdateDataSourceCallable(const UpdateDataSourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::UpdateDataSource, request);
  }
 
  template <typename UpdateDataSourceRequestT = Model::UpdateDataSourceRequest>
  void UpdateDataSourceAsync(const UpdateDataSourceRequestT& request, const UpdateDataSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::UpdateDataSource, request, handler, context);
  }
 
  virtual Model::UpdateDirectQueryDataSourceOutcome UpdateDirectQueryDataSource(
      const Model::UpdateDirectQueryDataSourceRequest& request) const;
 
  template <typename UpdateDirectQueryDataSourceRequestT = Model::UpdateDirectQueryDataSourceRequest>
  Model::UpdateDirectQueryDataSourceOutcomeCallable UpdateDirectQueryDataSourceCallable(
      const UpdateDirectQueryDataSourceRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::UpdateDirectQueryDataSource, request);
  }
 
  template <typename UpdateDirectQueryDataSourceRequestT = Model::UpdateDirectQueryDataSourceRequest>
  void UpdateDirectQueryDataSourceAsync(const UpdateDirectQueryDataSourceRequestT& request,
                                        const UpdateDirectQueryDataSourceResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::UpdateDirectQueryDataSource, request, handler, context);
  }
 
  virtual Model::UpdateDomainConfigOutcome UpdateDomainConfig(const Model::UpdateDomainConfigRequest& request) const;
 
  template <typename UpdateDomainConfigRequestT = Model::UpdateDomainConfigRequest>
  Model::UpdateDomainConfigOutcomeCallable UpdateDomainConfigCallable(const UpdateDomainConfigRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::UpdateDomainConfig, request);
  }
 
  template <typename UpdateDomainConfigRequestT = Model::UpdateDomainConfigRequest>
  void UpdateDomainConfigAsync(const UpdateDomainConfigRequestT& request, const UpdateDomainConfigResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::UpdateDomainConfig, request, handler, context);
  }
 
  virtual Model::UpdateIndexOutcome UpdateIndex(const Model::UpdateIndexRequest& request) const;
 
  template <typename UpdateIndexRequestT = Model::UpdateIndexRequest>
  Model::UpdateIndexOutcomeCallable UpdateIndexCallable(const UpdateIndexRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::UpdateIndex, request);
  }
 
  template <typename UpdateIndexRequestT = Model::UpdateIndexRequest>
  void UpdateIndexAsync(const UpdateIndexRequestT& request, const UpdateIndexResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::UpdateIndex, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::UpdatePackage, request, handler, context);
  }
 
  virtual Model::UpdatePackageScopeOutcome UpdatePackageScope(const Model::UpdatePackageScopeRequest& request) const;
 
  template <typename UpdatePackageScopeRequestT = Model::UpdatePackageScopeRequest>
  Model::UpdatePackageScopeOutcomeCallable UpdatePackageScopeCallable(const UpdatePackageScopeRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::UpdatePackageScope, request);
  }
 
  template <typename UpdatePackageScopeRequestT = Model::UpdatePackageScopeRequest>
  void UpdatePackageScopeAsync(const UpdatePackageScopeRequestT& request, const UpdatePackageScopeResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::UpdatePackageScope, request, handler, context);
  }
 
  virtual Model::UpdateScheduledActionOutcome UpdateScheduledAction(const Model::UpdateScheduledActionRequest& request) const;
 
  template <typename UpdateScheduledActionRequestT = Model::UpdateScheduledActionRequest>
  Model::UpdateScheduledActionOutcomeCallable UpdateScheduledActionCallable(const UpdateScheduledActionRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::UpdateScheduledAction, request);
  }
 
  template <typename UpdateScheduledActionRequestT = Model::UpdateScheduledActionRequest>
  void UpdateScheduledActionAsync(const UpdateScheduledActionRequestT& request, const UpdateScheduledActionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::UpdateScheduledAction, 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(&OpenSearchServiceClient::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(&OpenSearchServiceClient::UpdateVpcEndpoint, request, handler, context);
  }
 
  virtual Model::UpgradeDomainOutcome UpgradeDomain(const Model::UpgradeDomainRequest& request) const;
 
  template <typename UpgradeDomainRequestT = Model::UpgradeDomainRequest>
  Model::UpgradeDomainOutcomeCallable UpgradeDomainCallable(const UpgradeDomainRequestT& request) const {
    return SubmitCallable(&OpenSearchServiceClient::UpgradeDomain, request);
  }
 
  template <typename UpgradeDomainRequestT = Model::UpgradeDomainRequest>
  void UpgradeDomainAsync(const UpgradeDomainRequestT& request, const UpgradeDomainResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&OpenSearchServiceClient::UpgradeDomain, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<OpenSearchServiceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<OpenSearchServiceClient>;
  void init(const OpenSearchServiceClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, OpenSearchServiceError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  OpenSearchServiceClientConfiguration m_clientConfiguration;
  std::shared_ptr<OpenSearchServiceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace OpenSearchService
}  // namespace Aws