CostExplorerClient.h

 
#pragma once
#include <aws/ce/CostExplorer_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/ce/CostExplorerServiceClientModel.h>
 
namespace Aws
{
namespace CostExplorer
{
  class AWS_COSTEXPLORER_API CostExplorerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CostExplorerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CostExplorerClient>;
      void init(const CostExplorerClientConfiguration& clientConfiguration);
 
      CostExplorerClientConfiguration m_clientConfiguration;
      std::shared_ptr<CostExplorerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CostExplorer
} // namespace Aws