CloudSearchClient.h

 
#pragma once
#include <aws/cloudsearch/CloudSearchServiceClientModel.h>
#include <aws/cloudsearch/CloudSearch_EXPORTS.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
 
namespace Aws {
namespace CloudSearch {
class AWS_CLOUDSEARCH_API CloudSearchClient : public Aws::Client::AWSXMLClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<CloudSearchClient> {
 public:
  typedef Aws::Client::AWSXMLClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CloudSearchClientConfiguration ClientConfigurationType;
  typedef CloudSearchEndpointProvider EndpointProviderType;
 
  CloudSearchClient(
      const Aws::CloudSearch::CloudSearchClientConfiguration& clientConfiguration = Aws::CloudSearch::CloudSearchClientConfiguration(),
      std::shared_ptr<CloudSearchEndpointProviderBase> endpointProvider = nullptr);
 
  CloudSearchClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<CloudSearchEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CloudSearch::CloudSearchClientConfiguration& clientConfiguration = Aws::CloudSearch::CloudSearchClientConfiguration());
 
  CloudSearchClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<CloudSearchEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CloudSearch::CloudSearchClientConfiguration& clientConfiguration = Aws::CloudSearch::CloudSearchClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CloudSearchClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudSearchClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudSearchClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CloudSearchClient();
 
  Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
  virtual Model::BuildSuggestersOutcome BuildSuggesters(const Model::BuildSuggestersRequest& request) const;
 
  template <typename BuildSuggestersRequestT = Model::BuildSuggestersRequest>
  Model::BuildSuggestersOutcomeCallable BuildSuggestersCallable(const BuildSuggestersRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::BuildSuggesters, request);
  }
 
  template <typename BuildSuggestersRequestT = Model::BuildSuggestersRequest>
  void BuildSuggestersAsync(const BuildSuggestersRequestT& request, const BuildSuggestersResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::BuildSuggesters, 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(&CloudSearchClient::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(&CloudSearchClient::CreateDomain, request, handler, context);
  }
 
  virtual Model::DefineAnalysisSchemeOutcome DefineAnalysisScheme(const Model::DefineAnalysisSchemeRequest& request) const;
 
  template <typename DefineAnalysisSchemeRequestT = Model::DefineAnalysisSchemeRequest>
  Model::DefineAnalysisSchemeOutcomeCallable DefineAnalysisSchemeCallable(const DefineAnalysisSchemeRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DefineAnalysisScheme, request);
  }
 
  template <typename DefineAnalysisSchemeRequestT = Model::DefineAnalysisSchemeRequest>
  void DefineAnalysisSchemeAsync(const DefineAnalysisSchemeRequestT& request, const DefineAnalysisSchemeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DefineAnalysisScheme, request, handler, context);
  }
 
  virtual Model::DefineExpressionOutcome DefineExpression(const Model::DefineExpressionRequest& request) const;
 
  template <typename DefineExpressionRequestT = Model::DefineExpressionRequest>
  Model::DefineExpressionOutcomeCallable DefineExpressionCallable(const DefineExpressionRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DefineExpression, request);
  }
 
  template <typename DefineExpressionRequestT = Model::DefineExpressionRequest>
  void DefineExpressionAsync(const DefineExpressionRequestT& request, const DefineExpressionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DefineExpression, request, handler, context);
  }
 
  virtual Model::DefineIndexFieldOutcome DefineIndexField(const Model::DefineIndexFieldRequest& request) const;
 
  template <typename DefineIndexFieldRequestT = Model::DefineIndexFieldRequest>
  Model::DefineIndexFieldOutcomeCallable DefineIndexFieldCallable(const DefineIndexFieldRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DefineIndexField, request);
  }
 
  template <typename DefineIndexFieldRequestT = Model::DefineIndexFieldRequest>
  void DefineIndexFieldAsync(const DefineIndexFieldRequestT& request, const DefineIndexFieldResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DefineIndexField, request, handler, context);
  }
 
  virtual Model::DefineSuggesterOutcome DefineSuggester(const Model::DefineSuggesterRequest& request) const;
 
  template <typename DefineSuggesterRequestT = Model::DefineSuggesterRequest>
  Model::DefineSuggesterOutcomeCallable DefineSuggesterCallable(const DefineSuggesterRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DefineSuggester, request);
  }
 
  template <typename DefineSuggesterRequestT = Model::DefineSuggesterRequest>
  void DefineSuggesterAsync(const DefineSuggesterRequestT& request, const DefineSuggesterResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DefineSuggester, request, handler, context);
  }
 
  virtual Model::DeleteAnalysisSchemeOutcome DeleteAnalysisScheme(const Model::DeleteAnalysisSchemeRequest& request) const;
 
  template <typename DeleteAnalysisSchemeRequestT = Model::DeleteAnalysisSchemeRequest>
  Model::DeleteAnalysisSchemeOutcomeCallable DeleteAnalysisSchemeCallable(const DeleteAnalysisSchemeRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DeleteAnalysisScheme, request);
  }
 
  template <typename DeleteAnalysisSchemeRequestT = Model::DeleteAnalysisSchemeRequest>
  void DeleteAnalysisSchemeAsync(const DeleteAnalysisSchemeRequestT& request, const DeleteAnalysisSchemeResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DeleteAnalysisScheme, 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(&CloudSearchClient::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(&CloudSearchClient::DeleteDomain, request, handler, context);
  }
 
  virtual Model::DeleteExpressionOutcome DeleteExpression(const Model::DeleteExpressionRequest& request) const;
 
  template <typename DeleteExpressionRequestT = Model::DeleteExpressionRequest>
  Model::DeleteExpressionOutcomeCallable DeleteExpressionCallable(const DeleteExpressionRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DeleteExpression, request);
  }
 
  template <typename DeleteExpressionRequestT = Model::DeleteExpressionRequest>
  void DeleteExpressionAsync(const DeleteExpressionRequestT& request, const DeleteExpressionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DeleteExpression, request, handler, context);
  }
 
  virtual Model::DeleteIndexFieldOutcome DeleteIndexField(const Model::DeleteIndexFieldRequest& request) const;
 
  template <typename DeleteIndexFieldRequestT = Model::DeleteIndexFieldRequest>
  Model::DeleteIndexFieldOutcomeCallable DeleteIndexFieldCallable(const DeleteIndexFieldRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DeleteIndexField, request);
  }
 
  template <typename DeleteIndexFieldRequestT = Model::DeleteIndexFieldRequest>
  void DeleteIndexFieldAsync(const DeleteIndexFieldRequestT& request, const DeleteIndexFieldResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DeleteIndexField, request, handler, context);
  }
 
  virtual Model::DeleteSuggesterOutcome DeleteSuggester(const Model::DeleteSuggesterRequest& request) const;
 
  template <typename DeleteSuggesterRequestT = Model::DeleteSuggesterRequest>
  Model::DeleteSuggesterOutcomeCallable DeleteSuggesterCallable(const DeleteSuggesterRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DeleteSuggester, request);
  }
 
  template <typename DeleteSuggesterRequestT = Model::DeleteSuggesterRequest>
  void DeleteSuggesterAsync(const DeleteSuggesterRequestT& request, const DeleteSuggesterResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DeleteSuggester, request, handler, context);
  }
 
  virtual Model::DescribeAnalysisSchemesOutcome DescribeAnalysisSchemes(const Model::DescribeAnalysisSchemesRequest& request) const;
 
  template <typename DescribeAnalysisSchemesRequestT = Model::DescribeAnalysisSchemesRequest>
  Model::DescribeAnalysisSchemesOutcomeCallable DescribeAnalysisSchemesCallable(const DescribeAnalysisSchemesRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DescribeAnalysisSchemes, request);
  }
 
  template <typename DescribeAnalysisSchemesRequestT = Model::DescribeAnalysisSchemesRequest>
  void DescribeAnalysisSchemesAsync(const DescribeAnalysisSchemesRequestT& request,
                                    const DescribeAnalysisSchemesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DescribeAnalysisSchemes, request, handler, context);
  }
 
  virtual Model::DescribeAvailabilityOptionsOutcome DescribeAvailabilityOptions(
      const Model::DescribeAvailabilityOptionsRequest& request) const;
 
  template <typename DescribeAvailabilityOptionsRequestT = Model::DescribeAvailabilityOptionsRequest>
  Model::DescribeAvailabilityOptionsOutcomeCallable DescribeAvailabilityOptionsCallable(
      const DescribeAvailabilityOptionsRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DescribeAvailabilityOptions, request);
  }
 
  template <typename DescribeAvailabilityOptionsRequestT = Model::DescribeAvailabilityOptionsRequest>
  void DescribeAvailabilityOptionsAsync(const DescribeAvailabilityOptionsRequestT& request,
                                        const DescribeAvailabilityOptionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DescribeAvailabilityOptions, request, handler, context);
  }
 
  virtual Model::DescribeDomainEndpointOptionsOutcome DescribeDomainEndpointOptions(
      const Model::DescribeDomainEndpointOptionsRequest& request) const;
 
  template <typename DescribeDomainEndpointOptionsRequestT = Model::DescribeDomainEndpointOptionsRequest>
  Model::DescribeDomainEndpointOptionsOutcomeCallable DescribeDomainEndpointOptionsCallable(
      const DescribeDomainEndpointOptionsRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DescribeDomainEndpointOptions, request);
  }
 
  template <typename DescribeDomainEndpointOptionsRequestT = Model::DescribeDomainEndpointOptionsRequest>
  void DescribeDomainEndpointOptionsAsync(const DescribeDomainEndpointOptionsRequestT& request,
                                          const DescribeDomainEndpointOptionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DescribeDomainEndpointOptions, 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(&CloudSearchClient::DescribeDomains, request);
  }
 
  template <typename DescribeDomainsRequestT = Model::DescribeDomainsRequest>
  void DescribeDomainsAsync(const DescribeDomainsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const DescribeDomainsRequestT& request = {}) const {
    return SubmitAsync(&CloudSearchClient::DescribeDomains, request, handler, context);
  }
 
  virtual Model::DescribeExpressionsOutcome DescribeExpressions(const Model::DescribeExpressionsRequest& request) const;
 
  template <typename DescribeExpressionsRequestT = Model::DescribeExpressionsRequest>
  Model::DescribeExpressionsOutcomeCallable DescribeExpressionsCallable(const DescribeExpressionsRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DescribeExpressions, request);
  }
 
  template <typename DescribeExpressionsRequestT = Model::DescribeExpressionsRequest>
  void DescribeExpressionsAsync(const DescribeExpressionsRequestT& request, const DescribeExpressionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DescribeExpressions, request, handler, context);
  }
 
  virtual Model::DescribeIndexFieldsOutcome DescribeIndexFields(const Model::DescribeIndexFieldsRequest& request) const;
 
  template <typename DescribeIndexFieldsRequestT = Model::DescribeIndexFieldsRequest>
  Model::DescribeIndexFieldsOutcomeCallable DescribeIndexFieldsCallable(const DescribeIndexFieldsRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DescribeIndexFields, request);
  }
 
  template <typename DescribeIndexFieldsRequestT = Model::DescribeIndexFieldsRequest>
  void DescribeIndexFieldsAsync(const DescribeIndexFieldsRequestT& request, const DescribeIndexFieldsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DescribeIndexFields, request, handler, context);
  }
 
  virtual Model::DescribeScalingParametersOutcome DescribeScalingParameters(const Model::DescribeScalingParametersRequest& request) const;
 
  template <typename DescribeScalingParametersRequestT = Model::DescribeScalingParametersRequest>
  Model::DescribeScalingParametersOutcomeCallable DescribeScalingParametersCallable(
      const DescribeScalingParametersRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DescribeScalingParameters, request);
  }
 
  template <typename DescribeScalingParametersRequestT = Model::DescribeScalingParametersRequest>
  void DescribeScalingParametersAsync(const DescribeScalingParametersRequestT& request,
                                      const DescribeScalingParametersResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DescribeScalingParameters, request, handler, context);
  }
 
  virtual Model::DescribeServiceAccessPoliciesOutcome DescribeServiceAccessPolicies(
      const Model::DescribeServiceAccessPoliciesRequest& request) const;
 
  template <typename DescribeServiceAccessPoliciesRequestT = Model::DescribeServiceAccessPoliciesRequest>
  Model::DescribeServiceAccessPoliciesOutcomeCallable DescribeServiceAccessPoliciesCallable(
      const DescribeServiceAccessPoliciesRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DescribeServiceAccessPolicies, request);
  }
 
  template <typename DescribeServiceAccessPoliciesRequestT = Model::DescribeServiceAccessPoliciesRequest>
  void DescribeServiceAccessPoliciesAsync(const DescribeServiceAccessPoliciesRequestT& request,
                                          const DescribeServiceAccessPoliciesResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DescribeServiceAccessPolicies, request, handler, context);
  }
 
  virtual Model::DescribeSuggestersOutcome DescribeSuggesters(const Model::DescribeSuggestersRequest& request) const;
 
  template <typename DescribeSuggestersRequestT = Model::DescribeSuggestersRequest>
  Model::DescribeSuggestersOutcomeCallable DescribeSuggestersCallable(const DescribeSuggestersRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::DescribeSuggesters, request);
  }
 
  template <typename DescribeSuggestersRequestT = Model::DescribeSuggestersRequest>
  void DescribeSuggestersAsync(const DescribeSuggestersRequestT& request, const DescribeSuggestersResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::DescribeSuggesters, request, handler, context);
  }
 
  virtual Model::IndexDocumentsOutcome IndexDocuments(const Model::IndexDocumentsRequest& request) const;
 
  template <typename IndexDocumentsRequestT = Model::IndexDocumentsRequest>
  Model::IndexDocumentsOutcomeCallable IndexDocumentsCallable(const IndexDocumentsRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::IndexDocuments, request);
  }
 
  template <typename IndexDocumentsRequestT = Model::IndexDocumentsRequest>
  void IndexDocumentsAsync(const IndexDocumentsRequestT& request, const IndexDocumentsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::IndexDocuments, 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(&CloudSearchClient::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(&CloudSearchClient::ListDomainNames, request, handler, context);
  }
 
  virtual Model::UpdateAvailabilityOptionsOutcome UpdateAvailabilityOptions(const Model::UpdateAvailabilityOptionsRequest& request) const;
 
  template <typename UpdateAvailabilityOptionsRequestT = Model::UpdateAvailabilityOptionsRequest>
  Model::UpdateAvailabilityOptionsOutcomeCallable UpdateAvailabilityOptionsCallable(
      const UpdateAvailabilityOptionsRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::UpdateAvailabilityOptions, request);
  }
 
  template <typename UpdateAvailabilityOptionsRequestT = Model::UpdateAvailabilityOptionsRequest>
  void UpdateAvailabilityOptionsAsync(const UpdateAvailabilityOptionsRequestT& request,
                                      const UpdateAvailabilityOptionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::UpdateAvailabilityOptions, request, handler, context);
  }
 
  virtual Model::UpdateDomainEndpointOptionsOutcome UpdateDomainEndpointOptions(
      const Model::UpdateDomainEndpointOptionsRequest& request) const;
 
  template <typename UpdateDomainEndpointOptionsRequestT = Model::UpdateDomainEndpointOptionsRequest>
  Model::UpdateDomainEndpointOptionsOutcomeCallable UpdateDomainEndpointOptionsCallable(
      const UpdateDomainEndpointOptionsRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::UpdateDomainEndpointOptions, request);
  }
 
  template <typename UpdateDomainEndpointOptionsRequestT = Model::UpdateDomainEndpointOptionsRequest>
  void UpdateDomainEndpointOptionsAsync(const UpdateDomainEndpointOptionsRequestT& request,
                                        const UpdateDomainEndpointOptionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::UpdateDomainEndpointOptions, request, handler, context);
  }
 
  virtual Model::UpdateScalingParametersOutcome UpdateScalingParameters(const Model::UpdateScalingParametersRequest& request) const;
 
  template <typename UpdateScalingParametersRequestT = Model::UpdateScalingParametersRequest>
  Model::UpdateScalingParametersOutcomeCallable UpdateScalingParametersCallable(const UpdateScalingParametersRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::UpdateScalingParameters, request);
  }
 
  template <typename UpdateScalingParametersRequestT = Model::UpdateScalingParametersRequest>
  void UpdateScalingParametersAsync(const UpdateScalingParametersRequestT& request,
                                    const UpdateScalingParametersResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::UpdateScalingParameters, request, handler, context);
  }
 
  virtual Model::UpdateServiceAccessPoliciesOutcome UpdateServiceAccessPolicies(
      const Model::UpdateServiceAccessPoliciesRequest& request) const;
 
  template <typename UpdateServiceAccessPoliciesRequestT = Model::UpdateServiceAccessPoliciesRequest>
  Model::UpdateServiceAccessPoliciesOutcomeCallable UpdateServiceAccessPoliciesCallable(
      const UpdateServiceAccessPoliciesRequestT& request) const {
    return SubmitCallable(&CloudSearchClient::UpdateServiceAccessPolicies, request);
  }
 
  template <typename UpdateServiceAccessPoliciesRequestT = Model::UpdateServiceAccessPoliciesRequest>
  void UpdateServiceAccessPoliciesAsync(const UpdateServiceAccessPoliciesRequestT& request,
                                        const UpdateServiceAccessPoliciesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudSearchClient::UpdateServiceAccessPolicies, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<CloudSearchEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudSearchClient>;
  void init(const CloudSearchClientConfiguration& clientConfiguration);
 
  CloudSearchClientConfiguration m_clientConfiguration;
  std::shared_ptr<CloudSearchEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CloudSearch
}  // namespace Aws