CloudSearchClient.h

 
#pragma once
#include <aws/cloudsearch/CloudSearch_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/cloudsearch/CloudSearchServiceClientModel.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