ComputeOptimizerAutomationClient.h

 
#pragma once
#include <aws/compute-optimizer-automation/ComputeOptimizerAutomationPaginationBase.h>
#include <aws/compute-optimizer-automation/ComputeOptimizerAutomationServiceClientModel.h>
#include <aws/compute-optimizer-automation/ComputeOptimizerAutomationWaiter.h>
#include <aws/compute-optimizer-automation/ComputeOptimizerAutomation_EXPORTS.h>
#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>
 
namespace Aws {
namespace ComputeOptimizerAutomation {
class AWS_COMPUTEOPTIMIZERAUTOMATION_API ComputeOptimizerAutomationClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<ComputeOptimizerAutomationClient>,
      public ComputeOptimizerAutomationPaginationBase<ComputeOptimizerAutomationClient>,
      public ComputeOptimizerAutomationWaiter<ComputeOptimizerAutomationClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ComputeOptimizerAutomationClientConfiguration ClientConfigurationType;
  typedef ComputeOptimizerAutomationEndpointProvider EndpointProviderType;
 
  ComputeOptimizerAutomationClient(
      const Aws::ComputeOptimizerAutomation::ComputeOptimizerAutomationClientConfiguration& clientConfiguration =
          Aws::ComputeOptimizerAutomation::ComputeOptimizerAutomationClientConfiguration(),
      std::shared_ptr<ComputeOptimizerAutomationEndpointProviderBase> endpointProvider = nullptr);
 
  ComputeOptimizerAutomationClient(
      const Aws::Auth::AWSCredentials& credentials,
      std::shared_ptr<ComputeOptimizerAutomationEndpointProviderBase> endpointProvider = nullptr,
      const Aws::ComputeOptimizerAutomation::ComputeOptimizerAutomationClientConfiguration& clientConfiguration =
          Aws::ComputeOptimizerAutomation::ComputeOptimizerAutomationClientConfiguration());
 
  ComputeOptimizerAutomationClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<ComputeOptimizerAutomationEndpointProviderBase> endpointProvider = nullptr,
      const Aws::ComputeOptimizerAutomation::ComputeOptimizerAutomationClientConfiguration& clientConfiguration =
          Aws::ComputeOptimizerAutomation::ComputeOptimizerAutomationClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ComputeOptimizerAutomationClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ComputeOptimizerAutomationClient(const Aws::Auth::AWSCredentials& credentials,
                                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ComputeOptimizerAutomationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ComputeOptimizerAutomationClient();
 
  virtual Model::AssociateAccountsOutcome AssociateAccounts(const Model::AssociateAccountsRequest& request) const;
 
  template <typename AssociateAccountsRequestT = Model::AssociateAccountsRequest>
  Model::AssociateAccountsOutcomeCallable AssociateAccountsCallable(const AssociateAccountsRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::AssociateAccounts, request);
  }
 
  template <typename AssociateAccountsRequestT = Model::AssociateAccountsRequest>
  void AssociateAccountsAsync(const AssociateAccountsRequestT& request, const AssociateAccountsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::AssociateAccounts, request, handler, context);
  }
 
  virtual Model::CreateAutomationRuleOutcome CreateAutomationRule(const Model::CreateAutomationRuleRequest& request) const;
 
  template <typename CreateAutomationRuleRequestT = Model::CreateAutomationRuleRequest>
  Model::CreateAutomationRuleOutcomeCallable CreateAutomationRuleCallable(const CreateAutomationRuleRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::CreateAutomationRule, request);
  }
 
  template <typename CreateAutomationRuleRequestT = Model::CreateAutomationRuleRequest>
  void CreateAutomationRuleAsync(const CreateAutomationRuleRequestT& request, const CreateAutomationRuleResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::CreateAutomationRule, request, handler, context);
  }
 
  virtual Model::DeleteAutomationRuleOutcome DeleteAutomationRule(const Model::DeleteAutomationRuleRequest& request) const;
 
  template <typename DeleteAutomationRuleRequestT = Model::DeleteAutomationRuleRequest>
  Model::DeleteAutomationRuleOutcomeCallable DeleteAutomationRuleCallable(const DeleteAutomationRuleRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::DeleteAutomationRule, request);
  }
 
  template <typename DeleteAutomationRuleRequestT = Model::DeleteAutomationRuleRequest>
  void DeleteAutomationRuleAsync(const DeleteAutomationRuleRequestT& request, const DeleteAutomationRuleResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::DeleteAutomationRule, request, handler, context);
  }
 
  virtual Model::DisassociateAccountsOutcome DisassociateAccounts(const Model::DisassociateAccountsRequest& request) const;
 
  template <typename DisassociateAccountsRequestT = Model::DisassociateAccountsRequest>
  Model::DisassociateAccountsOutcomeCallable DisassociateAccountsCallable(const DisassociateAccountsRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::DisassociateAccounts, request);
  }
 
  template <typename DisassociateAccountsRequestT = Model::DisassociateAccountsRequest>
  void DisassociateAccountsAsync(const DisassociateAccountsRequestT& request, const DisassociateAccountsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::DisassociateAccounts, request, handler, context);
  }
 
  virtual Model::GetAutomationEventOutcome GetAutomationEvent(const Model::GetAutomationEventRequest& request) const;
 
  template <typename GetAutomationEventRequestT = Model::GetAutomationEventRequest>
  Model::GetAutomationEventOutcomeCallable GetAutomationEventCallable(const GetAutomationEventRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::GetAutomationEvent, request);
  }
 
  template <typename GetAutomationEventRequestT = Model::GetAutomationEventRequest>
  void GetAutomationEventAsync(const GetAutomationEventRequestT& request, const GetAutomationEventResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::GetAutomationEvent, request, handler, context);
  }
 
  virtual Model::GetAutomationRuleOutcome GetAutomationRule(const Model::GetAutomationRuleRequest& request) const;
 
  template <typename GetAutomationRuleRequestT = Model::GetAutomationRuleRequest>
  Model::GetAutomationRuleOutcomeCallable GetAutomationRuleCallable(const GetAutomationRuleRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::GetAutomationRule, request);
  }
 
  template <typename GetAutomationRuleRequestT = Model::GetAutomationRuleRequest>
  void GetAutomationRuleAsync(const GetAutomationRuleRequestT& request, const GetAutomationRuleResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::GetAutomationRule, request, handler, context);
  }
 
  virtual Model::GetEnrollmentConfigurationOutcome GetEnrollmentConfiguration(
      const Model::GetEnrollmentConfigurationRequest& request = {}) const;
 
  template <typename GetEnrollmentConfigurationRequestT = Model::GetEnrollmentConfigurationRequest>
  Model::GetEnrollmentConfigurationOutcomeCallable GetEnrollmentConfigurationCallable(
      const GetEnrollmentConfigurationRequestT& request = {}) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::GetEnrollmentConfiguration, request);
  }
 
  template <typename GetEnrollmentConfigurationRequestT = Model::GetEnrollmentConfigurationRequest>
  void GetEnrollmentConfigurationAsync(const GetEnrollmentConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const GetEnrollmentConfigurationRequestT& request = {}) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::GetEnrollmentConfiguration, request, handler, context);
  }
 
  virtual Model::ListAccountsOutcome ListAccounts(const Model::ListAccountsRequest& request = {}) const;
 
  template <typename ListAccountsRequestT = Model::ListAccountsRequest>
  Model::ListAccountsOutcomeCallable ListAccountsCallable(const ListAccountsRequestT& request = {}) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::ListAccounts, request);
  }
 
  template <typename ListAccountsRequestT = Model::ListAccountsRequest>
  void ListAccountsAsync(const ListAccountsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListAccountsRequestT& request = {}) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::ListAccounts, request, handler, context);
  }
 
  virtual Model::ListAutomationEventStepsOutcome ListAutomationEventSteps(const Model::ListAutomationEventStepsRequest& request) const;
 
  template <typename ListAutomationEventStepsRequestT = Model::ListAutomationEventStepsRequest>
  Model::ListAutomationEventStepsOutcomeCallable ListAutomationEventStepsCallable(const ListAutomationEventStepsRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::ListAutomationEventSteps, request);
  }
 
  template <typename ListAutomationEventStepsRequestT = Model::ListAutomationEventStepsRequest>
  void ListAutomationEventStepsAsync(const ListAutomationEventStepsRequestT& request,
                                     const ListAutomationEventStepsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::ListAutomationEventSteps, request, handler, context);
  }
 
  virtual Model::ListAutomationEventSummariesOutcome ListAutomationEventSummaries(
      const Model::ListAutomationEventSummariesRequest& request = {}) const;
 
  template <typename ListAutomationEventSummariesRequestT = Model::ListAutomationEventSummariesRequest>
  Model::ListAutomationEventSummariesOutcomeCallable ListAutomationEventSummariesCallable(
      const ListAutomationEventSummariesRequestT& request = {}) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::ListAutomationEventSummaries, request);
  }
 
  template <typename ListAutomationEventSummariesRequestT = Model::ListAutomationEventSummariesRequest>
  void ListAutomationEventSummariesAsync(const ListAutomationEventSummariesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListAutomationEventSummariesRequestT& request = {}) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::ListAutomationEventSummaries, request, handler, context);
  }
 
  virtual Model::ListAutomationEventsOutcome ListAutomationEvents(const Model::ListAutomationEventsRequest& request = {}) const;
 
  template <typename ListAutomationEventsRequestT = Model::ListAutomationEventsRequest>
  Model::ListAutomationEventsOutcomeCallable ListAutomationEventsCallable(const ListAutomationEventsRequestT& request = {}) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::ListAutomationEvents, request);
  }
 
  template <typename ListAutomationEventsRequestT = Model::ListAutomationEventsRequest>
  void ListAutomationEventsAsync(const ListAutomationEventsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListAutomationEventsRequestT& request = {}) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::ListAutomationEvents, request, handler, context);
  }
 
  virtual Model::ListAutomationRulePreviewOutcome ListAutomationRulePreview(const Model::ListAutomationRulePreviewRequest& request) const;
 
  template <typename ListAutomationRulePreviewRequestT = Model::ListAutomationRulePreviewRequest>
  Model::ListAutomationRulePreviewOutcomeCallable ListAutomationRulePreviewCallable(
      const ListAutomationRulePreviewRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::ListAutomationRulePreview, request);
  }
 
  template <typename ListAutomationRulePreviewRequestT = Model::ListAutomationRulePreviewRequest>
  void ListAutomationRulePreviewAsync(const ListAutomationRulePreviewRequestT& request,
                                      const ListAutomationRulePreviewResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::ListAutomationRulePreview, request, handler, context);
  }
 
  virtual Model::ListAutomationRulePreviewSummariesOutcome ListAutomationRulePreviewSummaries(
      const Model::ListAutomationRulePreviewSummariesRequest& request) const;
 
  template <typename ListAutomationRulePreviewSummariesRequestT = Model::ListAutomationRulePreviewSummariesRequest>
  Model::ListAutomationRulePreviewSummariesOutcomeCallable ListAutomationRulePreviewSummariesCallable(
      const ListAutomationRulePreviewSummariesRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::ListAutomationRulePreviewSummaries, request);
  }
 
  template <typename ListAutomationRulePreviewSummariesRequestT = Model::ListAutomationRulePreviewSummariesRequest>
  void ListAutomationRulePreviewSummariesAsync(const ListAutomationRulePreviewSummariesRequestT& request,
                                               const ListAutomationRulePreviewSummariesResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::ListAutomationRulePreviewSummaries, request, handler, context);
  }
 
  virtual Model::ListAutomationRulesOutcome ListAutomationRules(const Model::ListAutomationRulesRequest& request = {}) const;
 
  template <typename ListAutomationRulesRequestT = Model::ListAutomationRulesRequest>
  Model::ListAutomationRulesOutcomeCallable ListAutomationRulesCallable(const ListAutomationRulesRequestT& request = {}) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::ListAutomationRules, request);
  }
 
  template <typename ListAutomationRulesRequestT = Model::ListAutomationRulesRequest>
  void ListAutomationRulesAsync(const ListAutomationRulesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListAutomationRulesRequestT& request = {}) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::ListAutomationRules, request, handler, context);
  }
 
  virtual Model::ListRecommendedActionSummariesOutcome ListRecommendedActionSummaries(
      const Model::ListRecommendedActionSummariesRequest& request = {}) const;
 
  template <typename ListRecommendedActionSummariesRequestT = Model::ListRecommendedActionSummariesRequest>
  Model::ListRecommendedActionSummariesOutcomeCallable ListRecommendedActionSummariesCallable(
      const ListRecommendedActionSummariesRequestT& request = {}) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::ListRecommendedActionSummaries, request);
  }
 
  template <typename ListRecommendedActionSummariesRequestT = Model::ListRecommendedActionSummariesRequest>
  void ListRecommendedActionSummariesAsync(const ListRecommendedActionSummariesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ListRecommendedActionSummariesRequestT& request = {}) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::ListRecommendedActionSummaries, request, handler, context);
  }
 
  virtual Model::ListRecommendedActionsOutcome ListRecommendedActions(const Model::ListRecommendedActionsRequest& request = {}) const;
 
  template <typename ListRecommendedActionsRequestT = Model::ListRecommendedActionsRequest>
  Model::ListRecommendedActionsOutcomeCallable ListRecommendedActionsCallable(const ListRecommendedActionsRequestT& request = {}) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::ListRecommendedActions, request);
  }
 
  template <typename ListRecommendedActionsRequestT = Model::ListRecommendedActionsRequest>
  void ListRecommendedActionsAsync(const ListRecommendedActionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListRecommendedActionsRequestT& request = {}) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::ListRecommendedActions, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RollbackAutomationEventOutcome RollbackAutomationEvent(const Model::RollbackAutomationEventRequest& request) const;
 
  template <typename RollbackAutomationEventRequestT = Model::RollbackAutomationEventRequest>
  Model::RollbackAutomationEventOutcomeCallable RollbackAutomationEventCallable(const RollbackAutomationEventRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::RollbackAutomationEvent, request);
  }
 
  template <typename RollbackAutomationEventRequestT = Model::RollbackAutomationEventRequest>
  void RollbackAutomationEventAsync(const RollbackAutomationEventRequestT& request,
                                    const RollbackAutomationEventResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::RollbackAutomationEvent, request, handler, context);
  }
 
  virtual Model::StartAutomationEventOutcome StartAutomationEvent(const Model::StartAutomationEventRequest& request) const;
 
  template <typename StartAutomationEventRequestT = Model::StartAutomationEventRequest>
  Model::StartAutomationEventOutcomeCallable StartAutomationEventCallable(const StartAutomationEventRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::StartAutomationEvent, request);
  }
 
  template <typename StartAutomationEventRequestT = Model::StartAutomationEventRequest>
  void StartAutomationEventAsync(const StartAutomationEventRequestT& request, const StartAutomationEventResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::StartAutomationEvent, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAutomationRuleOutcome UpdateAutomationRule(const Model::UpdateAutomationRuleRequest& request) const;
 
  template <typename UpdateAutomationRuleRequestT = Model::UpdateAutomationRuleRequest>
  Model::UpdateAutomationRuleOutcomeCallable UpdateAutomationRuleCallable(const UpdateAutomationRuleRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::UpdateAutomationRule, request);
  }
 
  template <typename UpdateAutomationRuleRequestT = Model::UpdateAutomationRuleRequest>
  void UpdateAutomationRuleAsync(const UpdateAutomationRuleRequestT& request, const UpdateAutomationRuleResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::UpdateAutomationRule, request, handler, context);
  }
 
  virtual Model::UpdateEnrollmentConfigurationOutcome UpdateEnrollmentConfiguration(
      const Model::UpdateEnrollmentConfigurationRequest& request) const;
 
  template <typename UpdateEnrollmentConfigurationRequestT = Model::UpdateEnrollmentConfigurationRequest>
  Model::UpdateEnrollmentConfigurationOutcomeCallable UpdateEnrollmentConfigurationCallable(
      const UpdateEnrollmentConfigurationRequestT& request) const {
    return SubmitCallable(&ComputeOptimizerAutomationClient::UpdateEnrollmentConfiguration, request);
  }
 
  template <typename UpdateEnrollmentConfigurationRequestT = Model::UpdateEnrollmentConfigurationRequest>
  void UpdateEnrollmentConfigurationAsync(const UpdateEnrollmentConfigurationRequestT& request,
                                          const UpdateEnrollmentConfigurationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ComputeOptimizerAutomationClient::UpdateEnrollmentConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ComputeOptimizerAutomationEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ComputeOptimizerAutomationClient>;
  void init(const ComputeOptimizerAutomationClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ComputeOptimizerAutomationError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  ComputeOptimizerAutomationClientConfiguration m_clientConfiguration;
  std::shared_ptr<ComputeOptimizerAutomationEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ComputeOptimizerAutomation
}  // namespace Aws