CostExplorerClient.h

 
#pragma once
#include <aws/ce/CostExplorerPaginationBase.h>
#include <aws/ce/CostExplorerServiceClientModel.h>
#include <aws/ce/CostExplorerWaiter.h>
#include <aws/ce/CostExplorer_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 CostExplorer {
class AWS_COSTEXPLORER_API CostExplorerClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<CostExplorerClient>,
                                                public CostExplorerPaginationBase<CostExplorerClient>,
                                                public CostExplorerWaiter<CostExplorerClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CostExplorerClientConfiguration ClientConfigurationType;
  typedef CostExplorerEndpointProvider EndpointProviderType;
 
  CostExplorerClient(
      const Aws::CostExplorer::CostExplorerClientConfiguration& clientConfiguration = Aws::CostExplorer::CostExplorerClientConfiguration(),
      std::shared_ptr<CostExplorerEndpointProviderBase> endpointProvider = nullptr);
 
  CostExplorerClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<CostExplorerEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CostExplorer::CostExplorerClientConfiguration& clientConfiguration = Aws::CostExplorer::CostExplorerClientConfiguration());
 
  CostExplorerClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<CostExplorerEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CostExplorer::CostExplorerClientConfiguration& clientConfiguration = Aws::CostExplorer::CostExplorerClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CostExplorerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CostExplorerClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CostExplorerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CostExplorerClient();
 
  virtual Model::CreateAnomalyMonitorOutcome CreateAnomalyMonitor(const Model::CreateAnomalyMonitorRequest& request) const;
 
  template <typename CreateAnomalyMonitorRequestT = Model::CreateAnomalyMonitorRequest>
  Model::CreateAnomalyMonitorOutcomeCallable CreateAnomalyMonitorCallable(const CreateAnomalyMonitorRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::CreateAnomalyMonitor, request);
  }
 
  template <typename CreateAnomalyMonitorRequestT = Model::CreateAnomalyMonitorRequest>
  void CreateAnomalyMonitorAsync(const CreateAnomalyMonitorRequestT& request, const CreateAnomalyMonitorResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::CreateAnomalyMonitor, request, handler, context);
  }
 
  virtual Model::CreateAnomalySubscriptionOutcome CreateAnomalySubscription(const Model::CreateAnomalySubscriptionRequest& request) const;
 
  template <typename CreateAnomalySubscriptionRequestT = Model::CreateAnomalySubscriptionRequest>
  Model::CreateAnomalySubscriptionOutcomeCallable CreateAnomalySubscriptionCallable(
      const CreateAnomalySubscriptionRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::CreateAnomalySubscription, request);
  }
 
  template <typename CreateAnomalySubscriptionRequestT = Model::CreateAnomalySubscriptionRequest>
  void CreateAnomalySubscriptionAsync(const CreateAnomalySubscriptionRequestT& request,
                                      const CreateAnomalySubscriptionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::CreateAnomalySubscription, request, handler, context);
  }
 
  virtual Model::CreateCostCategoryDefinitionOutcome CreateCostCategoryDefinition(
      const Model::CreateCostCategoryDefinitionRequest& request) const;
 
  template <typename CreateCostCategoryDefinitionRequestT = Model::CreateCostCategoryDefinitionRequest>
  Model::CreateCostCategoryDefinitionOutcomeCallable CreateCostCategoryDefinitionCallable(
      const CreateCostCategoryDefinitionRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::CreateCostCategoryDefinition, request);
  }
 
  template <typename CreateCostCategoryDefinitionRequestT = Model::CreateCostCategoryDefinitionRequest>
  void CreateCostCategoryDefinitionAsync(const CreateCostCategoryDefinitionRequestT& request,
                                         const CreateCostCategoryDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::CreateCostCategoryDefinition, request, handler, context);
  }
 
  virtual Model::DeleteAnomalyMonitorOutcome DeleteAnomalyMonitor(const Model::DeleteAnomalyMonitorRequest& request) const;
 
  template <typename DeleteAnomalyMonitorRequestT = Model::DeleteAnomalyMonitorRequest>
  Model::DeleteAnomalyMonitorOutcomeCallable DeleteAnomalyMonitorCallable(const DeleteAnomalyMonitorRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::DeleteAnomalyMonitor, request);
  }
 
  template <typename DeleteAnomalyMonitorRequestT = Model::DeleteAnomalyMonitorRequest>
  void DeleteAnomalyMonitorAsync(const DeleteAnomalyMonitorRequestT& request, const DeleteAnomalyMonitorResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::DeleteAnomalyMonitor, request, handler, context);
  }
 
  virtual Model::DeleteAnomalySubscriptionOutcome DeleteAnomalySubscription(const Model::DeleteAnomalySubscriptionRequest& request) const;
 
  template <typename DeleteAnomalySubscriptionRequestT = Model::DeleteAnomalySubscriptionRequest>
  Model::DeleteAnomalySubscriptionOutcomeCallable DeleteAnomalySubscriptionCallable(
      const DeleteAnomalySubscriptionRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::DeleteAnomalySubscription, request);
  }
 
  template <typename DeleteAnomalySubscriptionRequestT = Model::DeleteAnomalySubscriptionRequest>
  void DeleteAnomalySubscriptionAsync(const DeleteAnomalySubscriptionRequestT& request,
                                      const DeleteAnomalySubscriptionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::DeleteAnomalySubscription, request, handler, context);
  }
 
  virtual Model::DeleteCostCategoryDefinitionOutcome DeleteCostCategoryDefinition(
      const Model::DeleteCostCategoryDefinitionRequest& request) const;
 
  template <typename DeleteCostCategoryDefinitionRequestT = Model::DeleteCostCategoryDefinitionRequest>
  Model::DeleteCostCategoryDefinitionOutcomeCallable DeleteCostCategoryDefinitionCallable(
      const DeleteCostCategoryDefinitionRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::DeleteCostCategoryDefinition, request);
  }
 
  template <typename DeleteCostCategoryDefinitionRequestT = Model::DeleteCostCategoryDefinitionRequest>
  void DeleteCostCategoryDefinitionAsync(const DeleteCostCategoryDefinitionRequestT& request,
                                         const DeleteCostCategoryDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::DeleteCostCategoryDefinition, request, handler, context);
  }
 
  virtual Model::DescribeCostCategoryDefinitionOutcome DescribeCostCategoryDefinition(
      const Model::DescribeCostCategoryDefinitionRequest& request) const;
 
  template <typename DescribeCostCategoryDefinitionRequestT = Model::DescribeCostCategoryDefinitionRequest>
  Model::DescribeCostCategoryDefinitionOutcomeCallable DescribeCostCategoryDefinitionCallable(
      const DescribeCostCategoryDefinitionRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::DescribeCostCategoryDefinition, request);
  }
 
  template <typename DescribeCostCategoryDefinitionRequestT = Model::DescribeCostCategoryDefinitionRequest>
  void DescribeCostCategoryDefinitionAsync(const DescribeCostCategoryDefinitionRequestT& request,
                                           const DescribeCostCategoryDefinitionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::DescribeCostCategoryDefinition, request, handler, context);
  }
 
  virtual Model::GetAnomaliesOutcome GetAnomalies(const Model::GetAnomaliesRequest& request) const;
 
  template <typename GetAnomaliesRequestT = Model::GetAnomaliesRequest>
  Model::GetAnomaliesOutcomeCallable GetAnomaliesCallable(const GetAnomaliesRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetAnomalies, request);
  }
 
  template <typename GetAnomaliesRequestT = Model::GetAnomaliesRequest>
  void GetAnomaliesAsync(const GetAnomaliesRequestT& request, const GetAnomaliesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetAnomalies, request, handler, context);
  }
 
  virtual Model::GetAnomalyMonitorsOutcome GetAnomalyMonitors(const Model::GetAnomalyMonitorsRequest& request = {}) const;
 
  template <typename GetAnomalyMonitorsRequestT = Model::GetAnomalyMonitorsRequest>
  Model::GetAnomalyMonitorsOutcomeCallable GetAnomalyMonitorsCallable(const GetAnomalyMonitorsRequestT& request = {}) const {
    return SubmitCallable(&CostExplorerClient::GetAnomalyMonitors, request);
  }
 
  template <typename GetAnomalyMonitorsRequestT = Model::GetAnomalyMonitorsRequest>
  void GetAnomalyMonitorsAsync(const GetAnomalyMonitorsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetAnomalyMonitorsRequestT& request = {}) const {
    return SubmitAsync(&CostExplorerClient::GetAnomalyMonitors, request, handler, context);
  }
 
  virtual Model::GetAnomalySubscriptionsOutcome GetAnomalySubscriptions(const Model::GetAnomalySubscriptionsRequest& request = {}) const;
 
  template <typename GetAnomalySubscriptionsRequestT = Model::GetAnomalySubscriptionsRequest>
  Model::GetAnomalySubscriptionsOutcomeCallable GetAnomalySubscriptionsCallable(const GetAnomalySubscriptionsRequestT& request = {}) const {
    return SubmitCallable(&CostExplorerClient::GetAnomalySubscriptions, request);
  }
 
  template <typename GetAnomalySubscriptionsRequestT = Model::GetAnomalySubscriptionsRequest>
  void GetAnomalySubscriptionsAsync(const GetAnomalySubscriptionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const GetAnomalySubscriptionsRequestT& request = {}) const {
    return SubmitAsync(&CostExplorerClient::GetAnomalySubscriptions, request, handler, context);
  }
 
  virtual Model::GetApproximateUsageRecordsOutcome GetApproximateUsageRecords(
      const Model::GetApproximateUsageRecordsRequest& request) const;
 
  template <typename GetApproximateUsageRecordsRequestT = Model::GetApproximateUsageRecordsRequest>
  Model::GetApproximateUsageRecordsOutcomeCallable GetApproximateUsageRecordsCallable(
      const GetApproximateUsageRecordsRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetApproximateUsageRecords, request);
  }
 
  template <typename GetApproximateUsageRecordsRequestT = Model::GetApproximateUsageRecordsRequest>
  void GetApproximateUsageRecordsAsync(const GetApproximateUsageRecordsRequestT& request,
                                       const GetApproximateUsageRecordsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetApproximateUsageRecords, request, handler, context);
  }
 
  virtual Model::GetCommitmentPurchaseAnalysisOutcome GetCommitmentPurchaseAnalysis(
      const Model::GetCommitmentPurchaseAnalysisRequest& request) const;
 
  template <typename GetCommitmentPurchaseAnalysisRequestT = Model::GetCommitmentPurchaseAnalysisRequest>
  Model::GetCommitmentPurchaseAnalysisOutcomeCallable GetCommitmentPurchaseAnalysisCallable(
      const GetCommitmentPurchaseAnalysisRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetCommitmentPurchaseAnalysis, request);
  }
 
  template <typename GetCommitmentPurchaseAnalysisRequestT = Model::GetCommitmentPurchaseAnalysisRequest>
  void GetCommitmentPurchaseAnalysisAsync(const GetCommitmentPurchaseAnalysisRequestT& request,
                                          const GetCommitmentPurchaseAnalysisResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetCommitmentPurchaseAnalysis, request, handler, context);
  }
 
  virtual Model::GetCostAndUsageOutcome GetCostAndUsage(const Model::GetCostAndUsageRequest& request) const;
 
  template <typename GetCostAndUsageRequestT = Model::GetCostAndUsageRequest>
  Model::GetCostAndUsageOutcomeCallable GetCostAndUsageCallable(const GetCostAndUsageRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetCostAndUsage, request);
  }
 
  template <typename GetCostAndUsageRequestT = Model::GetCostAndUsageRequest>
  void GetCostAndUsageAsync(const GetCostAndUsageRequestT& request, const GetCostAndUsageResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetCostAndUsage, request, handler, context);
  }
 
  virtual Model::GetCostAndUsageComparisonsOutcome GetCostAndUsageComparisons(
      const Model::GetCostAndUsageComparisonsRequest& request) const;
 
  template <typename GetCostAndUsageComparisonsRequestT = Model::GetCostAndUsageComparisonsRequest>
  Model::GetCostAndUsageComparisonsOutcomeCallable GetCostAndUsageComparisonsCallable(
      const GetCostAndUsageComparisonsRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetCostAndUsageComparisons, request);
  }
 
  template <typename GetCostAndUsageComparisonsRequestT = Model::GetCostAndUsageComparisonsRequest>
  void GetCostAndUsageComparisonsAsync(const GetCostAndUsageComparisonsRequestT& request,
                                       const GetCostAndUsageComparisonsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetCostAndUsageComparisons, request, handler, context);
  }
 
  virtual Model::GetCostAndUsageWithResourcesOutcome GetCostAndUsageWithResources(
      const Model::GetCostAndUsageWithResourcesRequest& request) const;
 
  template <typename GetCostAndUsageWithResourcesRequestT = Model::GetCostAndUsageWithResourcesRequest>
  Model::GetCostAndUsageWithResourcesOutcomeCallable GetCostAndUsageWithResourcesCallable(
      const GetCostAndUsageWithResourcesRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetCostAndUsageWithResources, request);
  }
 
  template <typename GetCostAndUsageWithResourcesRequestT = Model::GetCostAndUsageWithResourcesRequest>
  void GetCostAndUsageWithResourcesAsync(const GetCostAndUsageWithResourcesRequestT& request,
                                         const GetCostAndUsageWithResourcesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetCostAndUsageWithResources, request, handler, context);
  }
 
  virtual Model::GetCostCategoriesOutcome GetCostCategories(const Model::GetCostCategoriesRequest& request) const;
 
  template <typename GetCostCategoriesRequestT = Model::GetCostCategoriesRequest>
  Model::GetCostCategoriesOutcomeCallable GetCostCategoriesCallable(const GetCostCategoriesRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetCostCategories, request);
  }
 
  template <typename GetCostCategoriesRequestT = Model::GetCostCategoriesRequest>
  void GetCostCategoriesAsync(const GetCostCategoriesRequestT& request, const GetCostCategoriesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetCostCategories, request, handler, context);
  }
 
  virtual Model::GetCostComparisonDriversOutcome GetCostComparisonDrivers(const Model::GetCostComparisonDriversRequest& request) const;
 
  template <typename GetCostComparisonDriversRequestT = Model::GetCostComparisonDriversRequest>
  Model::GetCostComparisonDriversOutcomeCallable GetCostComparisonDriversCallable(const GetCostComparisonDriversRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetCostComparisonDrivers, request);
  }
 
  template <typename GetCostComparisonDriversRequestT = Model::GetCostComparisonDriversRequest>
  void GetCostComparisonDriversAsync(const GetCostComparisonDriversRequestT& request,
                                     const GetCostComparisonDriversResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetCostComparisonDrivers, request, handler, context);
  }
 
  virtual Model::GetCostForecastOutcome GetCostForecast(const Model::GetCostForecastRequest& request) const;
 
  template <typename GetCostForecastRequestT = Model::GetCostForecastRequest>
  Model::GetCostForecastOutcomeCallable GetCostForecastCallable(const GetCostForecastRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetCostForecast, request);
  }
 
  template <typename GetCostForecastRequestT = Model::GetCostForecastRequest>
  void GetCostForecastAsync(const GetCostForecastRequestT& request, const GetCostForecastResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetCostForecast, request, handler, context);
  }
 
  virtual Model::GetDimensionValuesOutcome GetDimensionValues(const Model::GetDimensionValuesRequest& request) const;
 
  template <typename GetDimensionValuesRequestT = Model::GetDimensionValuesRequest>
  Model::GetDimensionValuesOutcomeCallable GetDimensionValuesCallable(const GetDimensionValuesRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetDimensionValues, request);
  }
 
  template <typename GetDimensionValuesRequestT = Model::GetDimensionValuesRequest>
  void GetDimensionValuesAsync(const GetDimensionValuesRequestT& request, const GetDimensionValuesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetDimensionValues, request, handler, context);
  }
 
  virtual Model::GetReservationCoverageOutcome GetReservationCoverage(const Model::GetReservationCoverageRequest& request) const;
 
  template <typename GetReservationCoverageRequestT = Model::GetReservationCoverageRequest>
  Model::GetReservationCoverageOutcomeCallable GetReservationCoverageCallable(const GetReservationCoverageRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetReservationCoverage, request);
  }
 
  template <typename GetReservationCoverageRequestT = Model::GetReservationCoverageRequest>
  void GetReservationCoverageAsync(const GetReservationCoverageRequestT& request,
                                   const GetReservationCoverageResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetReservationCoverage, request, handler, context);
  }
 
  virtual Model::GetReservationPurchaseRecommendationOutcome GetReservationPurchaseRecommendation(
      const Model::GetReservationPurchaseRecommendationRequest& request) const;
 
  template <typename GetReservationPurchaseRecommendationRequestT = Model::GetReservationPurchaseRecommendationRequest>
  Model::GetReservationPurchaseRecommendationOutcomeCallable GetReservationPurchaseRecommendationCallable(
      const GetReservationPurchaseRecommendationRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetReservationPurchaseRecommendation, request);
  }
 
  template <typename GetReservationPurchaseRecommendationRequestT = Model::GetReservationPurchaseRecommendationRequest>
  void GetReservationPurchaseRecommendationAsync(const GetReservationPurchaseRecommendationRequestT& request,
                                                 const GetReservationPurchaseRecommendationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetReservationPurchaseRecommendation, request, handler, context);
  }
 
  virtual Model::GetReservationUtilizationOutcome GetReservationUtilization(const Model::GetReservationUtilizationRequest& request) const;
 
  template <typename GetReservationUtilizationRequestT = Model::GetReservationUtilizationRequest>
  Model::GetReservationUtilizationOutcomeCallable GetReservationUtilizationCallable(
      const GetReservationUtilizationRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetReservationUtilization, request);
  }
 
  template <typename GetReservationUtilizationRequestT = Model::GetReservationUtilizationRequest>
  void GetReservationUtilizationAsync(const GetReservationUtilizationRequestT& request,
                                      const GetReservationUtilizationResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetReservationUtilization, request, handler, context);
  }
 
  virtual Model::GetRightsizingRecommendationOutcome GetRightsizingRecommendation(
      const Model::GetRightsizingRecommendationRequest& request) const;
 
  template <typename GetRightsizingRecommendationRequestT = Model::GetRightsizingRecommendationRequest>
  Model::GetRightsizingRecommendationOutcomeCallable GetRightsizingRecommendationCallable(
      const GetRightsizingRecommendationRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetRightsizingRecommendation, request);
  }
 
  template <typename GetRightsizingRecommendationRequestT = Model::GetRightsizingRecommendationRequest>
  void GetRightsizingRecommendationAsync(const GetRightsizingRecommendationRequestT& request,
                                         const GetRightsizingRecommendationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetRightsizingRecommendation, request, handler, context);
  }
 
  virtual Model::GetSavingsPlanPurchaseRecommendationDetailsOutcome GetSavingsPlanPurchaseRecommendationDetails(
      const Model::GetSavingsPlanPurchaseRecommendationDetailsRequest& request) const;
 
  template <typename GetSavingsPlanPurchaseRecommendationDetailsRequestT = Model::GetSavingsPlanPurchaseRecommendationDetailsRequest>
  Model::GetSavingsPlanPurchaseRecommendationDetailsOutcomeCallable GetSavingsPlanPurchaseRecommendationDetailsCallable(
      const GetSavingsPlanPurchaseRecommendationDetailsRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetSavingsPlanPurchaseRecommendationDetails, request);
  }
 
  template <typename GetSavingsPlanPurchaseRecommendationDetailsRequestT = Model::GetSavingsPlanPurchaseRecommendationDetailsRequest>
  void GetSavingsPlanPurchaseRecommendationDetailsAsync(
      const GetSavingsPlanPurchaseRecommendationDetailsRequestT& request,
      const GetSavingsPlanPurchaseRecommendationDetailsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetSavingsPlanPurchaseRecommendationDetails, request, handler, context);
  }
 
  virtual Model::GetSavingsPlansCoverageOutcome GetSavingsPlansCoverage(const Model::GetSavingsPlansCoverageRequest& request) const;
 
  template <typename GetSavingsPlansCoverageRequestT = Model::GetSavingsPlansCoverageRequest>
  Model::GetSavingsPlansCoverageOutcomeCallable GetSavingsPlansCoverageCallable(const GetSavingsPlansCoverageRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetSavingsPlansCoverage, request);
  }
 
  template <typename GetSavingsPlansCoverageRequestT = Model::GetSavingsPlansCoverageRequest>
  void GetSavingsPlansCoverageAsync(const GetSavingsPlansCoverageRequestT& request,
                                    const GetSavingsPlansCoverageResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetSavingsPlansCoverage, request, handler, context);
  }
 
  virtual Model::GetSavingsPlansPurchaseRecommendationOutcome GetSavingsPlansPurchaseRecommendation(
      const Model::GetSavingsPlansPurchaseRecommendationRequest& request) const;
 
  template <typename GetSavingsPlansPurchaseRecommendationRequestT = Model::GetSavingsPlansPurchaseRecommendationRequest>
  Model::GetSavingsPlansPurchaseRecommendationOutcomeCallable GetSavingsPlansPurchaseRecommendationCallable(
      const GetSavingsPlansPurchaseRecommendationRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetSavingsPlansPurchaseRecommendation, request);
  }
 
  template <typename GetSavingsPlansPurchaseRecommendationRequestT = Model::GetSavingsPlansPurchaseRecommendationRequest>
  void GetSavingsPlansPurchaseRecommendationAsync(const GetSavingsPlansPurchaseRecommendationRequestT& request,
                                                  const GetSavingsPlansPurchaseRecommendationResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetSavingsPlansPurchaseRecommendation, request, handler, context);
  }
 
  virtual Model::GetSavingsPlansUtilizationOutcome GetSavingsPlansUtilization(
      const Model::GetSavingsPlansUtilizationRequest& request) const;
 
  template <typename GetSavingsPlansUtilizationRequestT = Model::GetSavingsPlansUtilizationRequest>
  Model::GetSavingsPlansUtilizationOutcomeCallable GetSavingsPlansUtilizationCallable(
      const GetSavingsPlansUtilizationRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetSavingsPlansUtilization, request);
  }
 
  template <typename GetSavingsPlansUtilizationRequestT = Model::GetSavingsPlansUtilizationRequest>
  void GetSavingsPlansUtilizationAsync(const GetSavingsPlansUtilizationRequestT& request,
                                       const GetSavingsPlansUtilizationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetSavingsPlansUtilization, request, handler, context);
  }
 
  virtual Model::GetSavingsPlansUtilizationDetailsOutcome GetSavingsPlansUtilizationDetails(
      const Model::GetSavingsPlansUtilizationDetailsRequest& request) const;
 
  template <typename GetSavingsPlansUtilizationDetailsRequestT = Model::GetSavingsPlansUtilizationDetailsRequest>
  Model::GetSavingsPlansUtilizationDetailsOutcomeCallable GetSavingsPlansUtilizationDetailsCallable(
      const GetSavingsPlansUtilizationDetailsRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetSavingsPlansUtilizationDetails, request);
  }
 
  template <typename GetSavingsPlansUtilizationDetailsRequestT = Model::GetSavingsPlansUtilizationDetailsRequest>
  void GetSavingsPlansUtilizationDetailsAsync(const GetSavingsPlansUtilizationDetailsRequestT& request,
                                              const GetSavingsPlansUtilizationDetailsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetSavingsPlansUtilizationDetails, request, handler, context);
  }
 
  virtual Model::GetTagsOutcome GetTags(const Model::GetTagsRequest& request) const;
 
  template <typename GetTagsRequestT = Model::GetTagsRequest>
  Model::GetTagsOutcomeCallable GetTagsCallable(const GetTagsRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetTags, request);
  }
 
  template <typename GetTagsRequestT = Model::GetTagsRequest>
  void GetTagsAsync(const GetTagsRequestT& request, const GetTagsResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetTags, request, handler, context);
  }
 
  virtual Model::GetUsageForecastOutcome GetUsageForecast(const Model::GetUsageForecastRequest& request) const;
 
  template <typename GetUsageForecastRequestT = Model::GetUsageForecastRequest>
  Model::GetUsageForecastOutcomeCallable GetUsageForecastCallable(const GetUsageForecastRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::GetUsageForecast, request);
  }
 
  template <typename GetUsageForecastRequestT = Model::GetUsageForecastRequest>
  void GetUsageForecastAsync(const GetUsageForecastRequestT& request, const GetUsageForecastResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::GetUsageForecast, request, handler, context);
  }
 
  virtual Model::ListCommitmentPurchaseAnalysesOutcome ListCommitmentPurchaseAnalyses(
      const Model::ListCommitmentPurchaseAnalysesRequest& request = {}) const;
 
  template <typename ListCommitmentPurchaseAnalysesRequestT = Model::ListCommitmentPurchaseAnalysesRequest>
  Model::ListCommitmentPurchaseAnalysesOutcomeCallable ListCommitmentPurchaseAnalysesCallable(
      const ListCommitmentPurchaseAnalysesRequestT& request = {}) const {
    return SubmitCallable(&CostExplorerClient::ListCommitmentPurchaseAnalyses, request);
  }
 
  template <typename ListCommitmentPurchaseAnalysesRequestT = Model::ListCommitmentPurchaseAnalysesRequest>
  void ListCommitmentPurchaseAnalysesAsync(const ListCommitmentPurchaseAnalysesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const ListCommitmentPurchaseAnalysesRequestT& request = {}) const {
    return SubmitAsync(&CostExplorerClient::ListCommitmentPurchaseAnalyses, request, handler, context);
  }
 
  virtual Model::ListCostAllocationTagBackfillHistoryOutcome ListCostAllocationTagBackfillHistory(
      const Model::ListCostAllocationTagBackfillHistoryRequest& request = {}) const;
 
  template <typename ListCostAllocationTagBackfillHistoryRequestT = Model::ListCostAllocationTagBackfillHistoryRequest>
  Model::ListCostAllocationTagBackfillHistoryOutcomeCallable ListCostAllocationTagBackfillHistoryCallable(
      const ListCostAllocationTagBackfillHistoryRequestT& request = {}) const {
    return SubmitCallable(&CostExplorerClient::ListCostAllocationTagBackfillHistory, request);
  }
 
  template <typename ListCostAllocationTagBackfillHistoryRequestT = Model::ListCostAllocationTagBackfillHistoryRequest>
  void ListCostAllocationTagBackfillHistoryAsync(const ListCostAllocationTagBackfillHistoryResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const ListCostAllocationTagBackfillHistoryRequestT& request = {}) const {
    return SubmitAsync(&CostExplorerClient::ListCostAllocationTagBackfillHistory, request, handler, context);
  }
 
  virtual Model::ListCostAllocationTagsOutcome ListCostAllocationTags(const Model::ListCostAllocationTagsRequest& request = {}) const;
 
  template <typename ListCostAllocationTagsRequestT = Model::ListCostAllocationTagsRequest>
  Model::ListCostAllocationTagsOutcomeCallable ListCostAllocationTagsCallable(const ListCostAllocationTagsRequestT& request = {}) const {
    return SubmitCallable(&CostExplorerClient::ListCostAllocationTags, request);
  }
 
  template <typename ListCostAllocationTagsRequestT = Model::ListCostAllocationTagsRequest>
  void ListCostAllocationTagsAsync(const ListCostAllocationTagsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListCostAllocationTagsRequestT& request = {}) const {
    return SubmitAsync(&CostExplorerClient::ListCostAllocationTags, request, handler, context);
  }
 
  virtual Model::ListCostCategoryDefinitionsOutcome ListCostCategoryDefinitions(
      const Model::ListCostCategoryDefinitionsRequest& request = {}) const;
 
  template <typename ListCostCategoryDefinitionsRequestT = Model::ListCostCategoryDefinitionsRequest>
  Model::ListCostCategoryDefinitionsOutcomeCallable ListCostCategoryDefinitionsCallable(
      const ListCostCategoryDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&CostExplorerClient::ListCostCategoryDefinitions, request);
  }
 
  template <typename ListCostCategoryDefinitionsRequestT = Model::ListCostCategoryDefinitionsRequest>
  void ListCostCategoryDefinitionsAsync(const ListCostCategoryDefinitionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListCostCategoryDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&CostExplorerClient::ListCostCategoryDefinitions, request, handler, context);
  }
 
  virtual Model::ListCostCategoryResourceAssociationsOutcome ListCostCategoryResourceAssociations(
      const Model::ListCostCategoryResourceAssociationsRequest& request = {}) const;
 
  template <typename ListCostCategoryResourceAssociationsRequestT = Model::ListCostCategoryResourceAssociationsRequest>
  Model::ListCostCategoryResourceAssociationsOutcomeCallable ListCostCategoryResourceAssociationsCallable(
      const ListCostCategoryResourceAssociationsRequestT& request = {}) const {
    return SubmitCallable(&CostExplorerClient::ListCostCategoryResourceAssociations, request);
  }
 
  template <typename ListCostCategoryResourceAssociationsRequestT = Model::ListCostCategoryResourceAssociationsRequest>
  void ListCostCategoryResourceAssociationsAsync(const ListCostCategoryResourceAssociationsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const ListCostCategoryResourceAssociationsRequestT& request = {}) const {
    return SubmitAsync(&CostExplorerClient::ListCostCategoryResourceAssociations, request, handler, context);
  }
 
  virtual Model::ListSavingsPlansPurchaseRecommendationGenerationOutcome ListSavingsPlansPurchaseRecommendationGeneration(
      const Model::ListSavingsPlansPurchaseRecommendationGenerationRequest& request = {}) const;
 
  template <
      typename ListSavingsPlansPurchaseRecommendationGenerationRequestT = Model::ListSavingsPlansPurchaseRecommendationGenerationRequest>
  Model::ListSavingsPlansPurchaseRecommendationGenerationOutcomeCallable ListSavingsPlansPurchaseRecommendationGenerationCallable(
      const ListSavingsPlansPurchaseRecommendationGenerationRequestT& request = {}) const {
    return SubmitCallable(&CostExplorerClient::ListSavingsPlansPurchaseRecommendationGeneration, request);
  }
 
  template <
      typename ListSavingsPlansPurchaseRecommendationGenerationRequestT = Model::ListSavingsPlansPurchaseRecommendationGenerationRequest>
  void ListSavingsPlansPurchaseRecommendationGenerationAsync(
      const ListSavingsPlansPurchaseRecommendationGenerationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const ListSavingsPlansPurchaseRecommendationGenerationRequestT& request = {}) const {
    return SubmitAsync(&CostExplorerClient::ListSavingsPlansPurchaseRecommendationGeneration, 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(&CostExplorerClient::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(&CostExplorerClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ProvideAnomalyFeedbackOutcome ProvideAnomalyFeedback(const Model::ProvideAnomalyFeedbackRequest& request) const;
 
  template <typename ProvideAnomalyFeedbackRequestT = Model::ProvideAnomalyFeedbackRequest>
  Model::ProvideAnomalyFeedbackOutcomeCallable ProvideAnomalyFeedbackCallable(const ProvideAnomalyFeedbackRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::ProvideAnomalyFeedback, request);
  }
 
  template <typename ProvideAnomalyFeedbackRequestT = Model::ProvideAnomalyFeedbackRequest>
  void ProvideAnomalyFeedbackAsync(const ProvideAnomalyFeedbackRequestT& request,
                                   const ProvideAnomalyFeedbackResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::ProvideAnomalyFeedback, request, handler, context);
  }
 
  virtual Model::StartCommitmentPurchaseAnalysisOutcome StartCommitmentPurchaseAnalysis(
      const Model::StartCommitmentPurchaseAnalysisRequest& request) const;
 
  template <typename StartCommitmentPurchaseAnalysisRequestT = Model::StartCommitmentPurchaseAnalysisRequest>
  Model::StartCommitmentPurchaseAnalysisOutcomeCallable StartCommitmentPurchaseAnalysisCallable(
      const StartCommitmentPurchaseAnalysisRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::StartCommitmentPurchaseAnalysis, request);
  }
 
  template <typename StartCommitmentPurchaseAnalysisRequestT = Model::StartCommitmentPurchaseAnalysisRequest>
  void StartCommitmentPurchaseAnalysisAsync(const StartCommitmentPurchaseAnalysisRequestT& request,
                                            const StartCommitmentPurchaseAnalysisResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::StartCommitmentPurchaseAnalysis, request, handler, context);
  }
 
  virtual Model::StartCostAllocationTagBackfillOutcome StartCostAllocationTagBackfill(
      const Model::StartCostAllocationTagBackfillRequest& request) const;
 
  template <typename StartCostAllocationTagBackfillRequestT = Model::StartCostAllocationTagBackfillRequest>
  Model::StartCostAllocationTagBackfillOutcomeCallable StartCostAllocationTagBackfillCallable(
      const StartCostAllocationTagBackfillRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::StartCostAllocationTagBackfill, request);
  }
 
  template <typename StartCostAllocationTagBackfillRequestT = Model::StartCostAllocationTagBackfillRequest>
  void StartCostAllocationTagBackfillAsync(const StartCostAllocationTagBackfillRequestT& request,
                                           const StartCostAllocationTagBackfillResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::StartCostAllocationTagBackfill, request, handler, context);
  }
 
  virtual Model::StartSavingsPlansPurchaseRecommendationGenerationOutcome StartSavingsPlansPurchaseRecommendationGeneration(
      const Model::StartSavingsPlansPurchaseRecommendationGenerationRequest& request = {}) const;
 
  template <
      typename StartSavingsPlansPurchaseRecommendationGenerationRequestT = Model::StartSavingsPlansPurchaseRecommendationGenerationRequest>
  Model::StartSavingsPlansPurchaseRecommendationGenerationOutcomeCallable StartSavingsPlansPurchaseRecommendationGenerationCallable(
      const StartSavingsPlansPurchaseRecommendationGenerationRequestT& request = {}) const {
    return SubmitCallable(&CostExplorerClient::StartSavingsPlansPurchaseRecommendationGeneration, request);
  }
 
  template <
      typename StartSavingsPlansPurchaseRecommendationGenerationRequestT = Model::StartSavingsPlansPurchaseRecommendationGenerationRequest>
  void StartSavingsPlansPurchaseRecommendationGenerationAsync(
      const StartSavingsPlansPurchaseRecommendationGenerationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
      const StartSavingsPlansPurchaseRecommendationGenerationRequestT& request = {}) const {
    return SubmitAsync(&CostExplorerClient::StartSavingsPlansPurchaseRecommendationGeneration, 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(&CostExplorerClient::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(&CostExplorerClient::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(&CostExplorerClient::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(&CostExplorerClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAnomalyMonitorOutcome UpdateAnomalyMonitor(const Model::UpdateAnomalyMonitorRequest& request) const;
 
  template <typename UpdateAnomalyMonitorRequestT = Model::UpdateAnomalyMonitorRequest>
  Model::UpdateAnomalyMonitorOutcomeCallable UpdateAnomalyMonitorCallable(const UpdateAnomalyMonitorRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::UpdateAnomalyMonitor, request);
  }
 
  template <typename UpdateAnomalyMonitorRequestT = Model::UpdateAnomalyMonitorRequest>
  void UpdateAnomalyMonitorAsync(const UpdateAnomalyMonitorRequestT& request, const UpdateAnomalyMonitorResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::UpdateAnomalyMonitor, request, handler, context);
  }
 
  virtual Model::UpdateAnomalySubscriptionOutcome UpdateAnomalySubscription(const Model::UpdateAnomalySubscriptionRequest& request) const;
 
  template <typename UpdateAnomalySubscriptionRequestT = Model::UpdateAnomalySubscriptionRequest>
  Model::UpdateAnomalySubscriptionOutcomeCallable UpdateAnomalySubscriptionCallable(
      const UpdateAnomalySubscriptionRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::UpdateAnomalySubscription, request);
  }
 
  template <typename UpdateAnomalySubscriptionRequestT = Model::UpdateAnomalySubscriptionRequest>
  void UpdateAnomalySubscriptionAsync(const UpdateAnomalySubscriptionRequestT& request,
                                      const UpdateAnomalySubscriptionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::UpdateAnomalySubscription, request, handler, context);
  }
 
  virtual Model::UpdateCostAllocationTagsStatusOutcome UpdateCostAllocationTagsStatus(
      const Model::UpdateCostAllocationTagsStatusRequest& request) const;
 
  template <typename UpdateCostAllocationTagsStatusRequestT = Model::UpdateCostAllocationTagsStatusRequest>
  Model::UpdateCostAllocationTagsStatusOutcomeCallable UpdateCostAllocationTagsStatusCallable(
      const UpdateCostAllocationTagsStatusRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::UpdateCostAllocationTagsStatus, request);
  }
 
  template <typename UpdateCostAllocationTagsStatusRequestT = Model::UpdateCostAllocationTagsStatusRequest>
  void UpdateCostAllocationTagsStatusAsync(const UpdateCostAllocationTagsStatusRequestT& request,
                                           const UpdateCostAllocationTagsStatusResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::UpdateCostAllocationTagsStatus, request, handler, context);
  }
 
  virtual Model::UpdateCostCategoryDefinitionOutcome UpdateCostCategoryDefinition(
      const Model::UpdateCostCategoryDefinitionRequest& request) const;
 
  template <typename UpdateCostCategoryDefinitionRequestT = Model::UpdateCostCategoryDefinitionRequest>
  Model::UpdateCostCategoryDefinitionOutcomeCallable UpdateCostCategoryDefinitionCallable(
      const UpdateCostCategoryDefinitionRequestT& request) const {
    return SubmitCallable(&CostExplorerClient::UpdateCostCategoryDefinition, request);
  }
 
  template <typename UpdateCostCategoryDefinitionRequestT = Model::UpdateCostCategoryDefinitionRequest>
  void UpdateCostCategoryDefinitionAsync(const UpdateCostCategoryDefinitionRequestT& request,
                                         const UpdateCostCategoryDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CostExplorerClient::UpdateCostCategoryDefinition, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CostExplorerEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CostExplorerClient>;
  void init(const CostExplorerClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CostExplorerError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  CostExplorerClientConfiguration m_clientConfiguration;
  std::shared_ptr<CostExplorerEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CostExplorer
}  // namespace Aws