BillingClient.h

 
#pragma once
#include <aws/billing/BillingPaginationBase.h>
#include <aws/billing/BillingServiceClientModel.h>
#include <aws/billing/BillingWaiter.h>
#include <aws/billing/Billing_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 Billing {
class AWS_BILLING_API BillingClient : public Aws::Client::AWSJsonClient,
                                      public Aws::Client::ClientWithAsyncTemplateMethods<BillingClient>,
                                      public BillingPaginationBase<BillingClient>,
                                      public BillingWaiter<BillingClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef BillingClientConfiguration ClientConfigurationType;
  typedef BillingEndpointProvider EndpointProviderType;
 
  BillingClient(const Aws::Billing::BillingClientConfiguration& clientConfiguration = Aws::Billing::BillingClientConfiguration(),
                std::shared_ptr<BillingEndpointProviderBase> endpointProvider = nullptr);
 
  BillingClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<BillingEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Billing::BillingClientConfiguration& clientConfiguration = Aws::Billing::BillingClientConfiguration());
 
  BillingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                std::shared_ptr<BillingEndpointProviderBase> endpointProvider = nullptr,
                const Aws::Billing::BillingClientConfiguration& clientConfiguration = Aws::Billing::BillingClientConfiguration());
 
  /* Legacy constructors due deprecation */
  BillingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  BillingClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  BillingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~BillingClient();
 
  virtual Model::AssociateContractOutcome AssociateContract(const Model::AssociateContractRequest& request) const;
 
  template <typename AssociateContractRequestT = Model::AssociateContractRequest>
  Model::AssociateContractOutcomeCallable AssociateContractCallable(const AssociateContractRequestT& request) const {
    return SubmitCallable(&BillingClient::AssociateContract, request);
  }
 
  template <typename AssociateContractRequestT = Model::AssociateContractRequest>
  void AssociateContractAsync(const AssociateContractRequestT& request, const AssociateContractResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::AssociateContract, request, handler, context);
  }
 
  virtual Model::AssociateSourceViewsOutcome AssociateSourceViews(const Model::AssociateSourceViewsRequest& request) const;
 
  template <typename AssociateSourceViewsRequestT = Model::AssociateSourceViewsRequest>
  Model::AssociateSourceViewsOutcomeCallable AssociateSourceViewsCallable(const AssociateSourceViewsRequestT& request) const {
    return SubmitCallable(&BillingClient::AssociateSourceViews, request);
  }
 
  template <typename AssociateSourceViewsRequestT = Model::AssociateSourceViewsRequest>
  void AssociateSourceViewsAsync(const AssociateSourceViewsRequestT& request, const AssociateSourceViewsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::AssociateSourceViews, request, handler, context);
  }
 
  virtual Model::CancelContractualInvestmentAttestationOutcome CancelContractualInvestmentAttestation(
      const Model::CancelContractualInvestmentAttestationRequest& request) const;
 
  template <typename CancelContractualInvestmentAttestationRequestT = Model::CancelContractualInvestmentAttestationRequest>
  Model::CancelContractualInvestmentAttestationOutcomeCallable CancelContractualInvestmentAttestationCallable(
      const CancelContractualInvestmentAttestationRequestT& request) const {
    return SubmitCallable(&BillingClient::CancelContractualInvestmentAttestation, request);
  }
 
  template <typename CancelContractualInvestmentAttestationRequestT = Model::CancelContractualInvestmentAttestationRequest>
  void CancelContractualInvestmentAttestationAsync(const CancelContractualInvestmentAttestationRequestT& request,
                                                   const CancelContractualInvestmentAttestationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::CancelContractualInvestmentAttestation, request, handler, context);
  }
 
  virtual Model::CreateBillingViewOutcome CreateBillingView(const Model::CreateBillingViewRequest& request) const;
 
  template <typename CreateBillingViewRequestT = Model::CreateBillingViewRequest>
  Model::CreateBillingViewOutcomeCallable CreateBillingViewCallable(const CreateBillingViewRequestT& request) const {
    return SubmitCallable(&BillingClient::CreateBillingView, request);
  }
 
  template <typename CreateBillingViewRequestT = Model::CreateBillingViewRequest>
  void CreateBillingViewAsync(const CreateBillingViewRequestT& request, const CreateBillingViewResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::CreateBillingView, request, handler, context);
  }
 
  virtual Model::CreateContractualInvestmentAttestationOutcome CreateContractualInvestmentAttestation(
      const Model::CreateContractualInvestmentAttestationRequest& request) const;
 
  template <typename CreateContractualInvestmentAttestationRequestT = Model::CreateContractualInvestmentAttestationRequest>
  Model::CreateContractualInvestmentAttestationOutcomeCallable CreateContractualInvestmentAttestationCallable(
      const CreateContractualInvestmentAttestationRequestT& request) const {
    return SubmitCallable(&BillingClient::CreateContractualInvestmentAttestation, request);
  }
 
  template <typename CreateContractualInvestmentAttestationRequestT = Model::CreateContractualInvestmentAttestationRequest>
  void CreateContractualInvestmentAttestationAsync(const CreateContractualInvestmentAttestationRequestT& request,
                                                   const CreateContractualInvestmentAttestationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::CreateContractualInvestmentAttestation, request, handler, context);
  }
 
  virtual Model::DeleteBillingViewOutcome DeleteBillingView(const Model::DeleteBillingViewRequest& request) const;
 
  template <typename DeleteBillingViewRequestT = Model::DeleteBillingViewRequest>
  Model::DeleteBillingViewOutcomeCallable DeleteBillingViewCallable(const DeleteBillingViewRequestT& request) const {
    return SubmitCallable(&BillingClient::DeleteBillingView, request);
  }
 
  template <typename DeleteBillingViewRequestT = Model::DeleteBillingViewRequest>
  void DeleteBillingViewAsync(const DeleteBillingViewRequestT& request, const DeleteBillingViewResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::DeleteBillingView, request, handler, context);
  }
 
  virtual Model::DisassociateContractOutcome DisassociateContract(const Model::DisassociateContractRequest& request) const;
 
  template <typename DisassociateContractRequestT = Model::DisassociateContractRequest>
  Model::DisassociateContractOutcomeCallable DisassociateContractCallable(const DisassociateContractRequestT& request) const {
    return SubmitCallable(&BillingClient::DisassociateContract, request);
  }
 
  template <typename DisassociateContractRequestT = Model::DisassociateContractRequest>
  void DisassociateContractAsync(const DisassociateContractRequestT& request, const DisassociateContractResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::DisassociateContract, request, handler, context);
  }
 
  virtual Model::DisassociateSourceViewsOutcome DisassociateSourceViews(const Model::DisassociateSourceViewsRequest& request) const;
 
  template <typename DisassociateSourceViewsRequestT = Model::DisassociateSourceViewsRequest>
  Model::DisassociateSourceViewsOutcomeCallable DisassociateSourceViewsCallable(const DisassociateSourceViewsRequestT& request) const {
    return SubmitCallable(&BillingClient::DisassociateSourceViews, request);
  }
 
  template <typename DisassociateSourceViewsRequestT = Model::DisassociateSourceViewsRequest>
  void DisassociateSourceViewsAsync(const DisassociateSourceViewsRequestT& request,
                                    const DisassociateSourceViewsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::DisassociateSourceViews, request, handler, context);
  }
 
  virtual Model::GetBillingPreferencesOutcome GetBillingPreferences(const Model::GetBillingPreferencesRequest& request) const;
 
  template <typename GetBillingPreferencesRequestT = Model::GetBillingPreferencesRequest>
  Model::GetBillingPreferencesOutcomeCallable GetBillingPreferencesCallable(const GetBillingPreferencesRequestT& request) const {
    return SubmitCallable(&BillingClient::GetBillingPreferences, request);
  }
 
  template <typename GetBillingPreferencesRequestT = Model::GetBillingPreferencesRequest>
  void GetBillingPreferencesAsync(const GetBillingPreferencesRequestT& request, const GetBillingPreferencesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::GetBillingPreferences, request, handler, context);
  }
 
  virtual Model::GetBillingViewOutcome GetBillingView(const Model::GetBillingViewRequest& request) const;
 
  template <typename GetBillingViewRequestT = Model::GetBillingViewRequest>
  Model::GetBillingViewOutcomeCallable GetBillingViewCallable(const GetBillingViewRequestT& request) const {
    return SubmitCallable(&BillingClient::GetBillingView, request);
  }
 
  template <typename GetBillingViewRequestT = Model::GetBillingViewRequest>
  void GetBillingViewAsync(const GetBillingViewRequestT& request, const GetBillingViewResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::GetBillingView, request, handler, context);
  }
 
  virtual Model::GetContractInformationOutcome GetContractInformation(const Model::GetContractInformationRequest& request) const;
 
  template <typename GetContractInformationRequestT = Model::GetContractInformationRequest>
  Model::GetContractInformationOutcomeCallable GetContractInformationCallable(const GetContractInformationRequestT& request) const {
    return SubmitCallable(&BillingClient::GetContractInformation, request);
  }
 
  template <typename GetContractInformationRequestT = Model::GetContractInformationRequest>
  void GetContractInformationAsync(const GetContractInformationRequestT& request,
                                   const GetContractInformationResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::GetContractInformation, request, handler, context);
  }
 
  virtual Model::GetCreditAllocationHistoryOutcome GetCreditAllocationHistory(
      const Model::GetCreditAllocationHistoryRequest& request) const;
 
  template <typename GetCreditAllocationHistoryRequestT = Model::GetCreditAllocationHistoryRequest>
  Model::GetCreditAllocationHistoryOutcomeCallable GetCreditAllocationHistoryCallable(
      const GetCreditAllocationHistoryRequestT& request) const {
    return SubmitCallable(&BillingClient::GetCreditAllocationHistory, request);
  }
 
  template <typename GetCreditAllocationHistoryRequestT = Model::GetCreditAllocationHistoryRequest>
  void GetCreditAllocationHistoryAsync(const GetCreditAllocationHistoryRequestT& request,
                                       const GetCreditAllocationHistoryResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::GetCreditAllocationHistory, request, handler, context);
  }
 
  virtual Model::GetCreditsOutcome GetCredits(const Model::GetCreditsRequest& request) const;
 
  template <typename GetCreditsRequestT = Model::GetCreditsRequest>
  Model::GetCreditsOutcomeCallable GetCreditsCallable(const GetCreditsRequestT& request) const {
    return SubmitCallable(&BillingClient::GetCredits, request);
  }
 
  template <typename GetCreditsRequestT = Model::GetCreditsRequest>
  void GetCreditsAsync(const GetCreditsRequestT& request, const GetCreditsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::GetCredits, request, handler, context);
  }
 
  virtual Model::GetEnterpriseSupportChargeSummaryOutcome GetEnterpriseSupportChargeSummary(
      const Model::GetEnterpriseSupportChargeSummaryRequest& request) const;
 
  template <typename GetEnterpriseSupportChargeSummaryRequestT = Model::GetEnterpriseSupportChargeSummaryRequest>
  Model::GetEnterpriseSupportChargeSummaryOutcomeCallable GetEnterpriseSupportChargeSummaryCallable(
      const GetEnterpriseSupportChargeSummaryRequestT& request) const {
    return SubmitCallable(&BillingClient::GetEnterpriseSupportChargeSummary, request);
  }
 
  template <typename GetEnterpriseSupportChargeSummaryRequestT = Model::GetEnterpriseSupportChargeSummaryRequest>
  void GetEnterpriseSupportChargeSummaryAsync(const GetEnterpriseSupportChargeSummaryRequestT& request,
                                              const GetEnterpriseSupportChargeSummaryResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::GetEnterpriseSupportChargeSummary, request, handler, context);
  }
 
  virtual Model::GetEnterpriseSupportContractDetailsOutcome GetEnterpriseSupportContractDetails(
      const Model::GetEnterpriseSupportContractDetailsRequest& request) const;
 
  template <typename GetEnterpriseSupportContractDetailsRequestT = Model::GetEnterpriseSupportContractDetailsRequest>
  Model::GetEnterpriseSupportContractDetailsOutcomeCallable GetEnterpriseSupportContractDetailsCallable(
      const GetEnterpriseSupportContractDetailsRequestT& request) const {
    return SubmitCallable(&BillingClient::GetEnterpriseSupportContractDetails, request);
  }
 
  template <typename GetEnterpriseSupportContractDetailsRequestT = Model::GetEnterpriseSupportContractDetailsRequest>
  void GetEnterpriseSupportContractDetailsAsync(const GetEnterpriseSupportContractDetailsRequestT& request,
                                                const GetEnterpriseSupportContractDetailsResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::GetEnterpriseSupportContractDetails, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&BillingClient::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::ListBillingViewSegmentsOutcome ListBillingViewSegments(const Model::ListBillingViewSegmentsRequest& request = {}) const;
 
  template <typename ListBillingViewSegmentsRequestT = Model::ListBillingViewSegmentsRequest>
  Model::ListBillingViewSegmentsOutcomeCallable ListBillingViewSegmentsCallable(const ListBillingViewSegmentsRequestT& request = {}) const {
    return SubmitCallable(&BillingClient::ListBillingViewSegments, request);
  }
 
  template <typename ListBillingViewSegmentsRequestT = Model::ListBillingViewSegmentsRequest>
  void ListBillingViewSegmentsAsync(const ListBillingViewSegmentsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListBillingViewSegmentsRequestT& request = {}) const {
    return SubmitAsync(&BillingClient::ListBillingViewSegments, request, handler, context);
  }
 
  virtual Model::ListBillingViewsOutcome ListBillingViews(const Model::ListBillingViewsRequest& request = {}) const;
 
  template <typename ListBillingViewsRequestT = Model::ListBillingViewsRequest>
  Model::ListBillingViewsOutcomeCallable ListBillingViewsCallable(const ListBillingViewsRequestT& request = {}) const {
    return SubmitCallable(&BillingClient::ListBillingViews, request);
  }
 
  template <typename ListBillingViewsRequestT = Model::ListBillingViewsRequest>
  void ListBillingViewsAsync(const ListBillingViewsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListBillingViewsRequestT& request = {}) const {
    return SubmitAsync(&BillingClient::ListBillingViews, request, handler, context);
  }
 
  virtual Model::ListBusinessSupportAccountChargesOutcome ListBusinessSupportAccountCharges(
      const Model::ListBusinessSupportAccountChargesRequest& request) const;
 
  template <typename ListBusinessSupportAccountChargesRequestT = Model::ListBusinessSupportAccountChargesRequest>
  Model::ListBusinessSupportAccountChargesOutcomeCallable ListBusinessSupportAccountChargesCallable(
      const ListBusinessSupportAccountChargesRequestT& request) const {
    return SubmitCallable(&BillingClient::ListBusinessSupportAccountCharges, request);
  }
 
  template <typename ListBusinessSupportAccountChargesRequestT = Model::ListBusinessSupportAccountChargesRequest>
  void ListBusinessSupportAccountChargesAsync(const ListBusinessSupportAccountChargesRequestT& request,
                                              const ListBusinessSupportAccountChargesResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::ListBusinessSupportAccountCharges, request, handler, context);
  }
 
  virtual Model::ListBusinessSupportSubscriptionHistoryOutcome ListBusinessSupportSubscriptionHistory(
      const Model::ListBusinessSupportSubscriptionHistoryRequest& request = {}) const;
 
  template <typename ListBusinessSupportSubscriptionHistoryRequestT = Model::ListBusinessSupportSubscriptionHistoryRequest>
  Model::ListBusinessSupportSubscriptionHistoryOutcomeCallable ListBusinessSupportSubscriptionHistoryCallable(
      const ListBusinessSupportSubscriptionHistoryRequestT& request = {}) const {
    return SubmitCallable(&BillingClient::ListBusinessSupportSubscriptionHistory, request);
  }
 
  template <typename ListBusinessSupportSubscriptionHistoryRequestT = Model::ListBusinessSupportSubscriptionHistoryRequest>
  void ListBusinessSupportSubscriptionHistoryAsync(const ListBusinessSupportSubscriptionHistoryResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const ListBusinessSupportSubscriptionHistoryRequestT& request = {}) const {
    return SubmitAsync(&BillingClient::ListBusinessSupportSubscriptionHistory, request, handler, context);
  }
 
  virtual Model::ListContractsOutcome ListContracts(const Model::ListContractsRequest& request = {}) const;
 
  template <typename ListContractsRequestT = Model::ListContractsRequest>
  Model::ListContractsOutcomeCallable ListContractsCallable(const ListContractsRequestT& request = {}) const {
    return SubmitCallable(&BillingClient::ListContracts, request);
  }
 
  template <typename ListContractsRequestT = Model::ListContractsRequest>
  void ListContractsAsync(const ListContractsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListContractsRequestT& request = {}) const {
    return SubmitAsync(&BillingClient::ListContracts, request, handler, context);
  }
 
  virtual Model::ListContractualInvestmentAttestationsOutcome ListContractualInvestmentAttestations(
      const Model::ListContractualInvestmentAttestationsRequest& request) const;
 
  template <typename ListContractualInvestmentAttestationsRequestT = Model::ListContractualInvestmentAttestationsRequest>
  Model::ListContractualInvestmentAttestationsOutcomeCallable ListContractualInvestmentAttestationsCallable(
      const ListContractualInvestmentAttestationsRequestT& request) const {
    return SubmitCallable(&BillingClient::ListContractualInvestmentAttestations, request);
  }
 
  template <typename ListContractualInvestmentAttestationsRequestT = Model::ListContractualInvestmentAttestationsRequest>
  void ListContractualInvestmentAttestationsAsync(const ListContractualInvestmentAttestationsRequestT& request,
                                                  const ListContractualInvestmentAttestationsResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::ListContractualInvestmentAttestations, request, handler, context);
  }
 
  virtual Model::ListContractualInvestmentSummariesOutcome ListContractualInvestmentSummaries(
      const Model::ListContractualInvestmentSummariesRequest& request) const;
 
  template <typename ListContractualInvestmentSummariesRequestT = Model::ListContractualInvestmentSummariesRequest>
  Model::ListContractualInvestmentSummariesOutcomeCallable ListContractualInvestmentSummariesCallable(
      const ListContractualInvestmentSummariesRequestT& request) const {
    return SubmitCallable(&BillingClient::ListContractualInvestmentSummaries, request);
  }
 
  template <typename ListContractualInvestmentSummariesRequestT = Model::ListContractualInvestmentSummariesRequest>
  void ListContractualInvestmentSummariesAsync(const ListContractualInvestmentSummariesRequestT& request,
                                               const ListContractualInvestmentSummariesResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::ListContractualInvestmentSummaries, request, handler, context);
  }
 
  virtual Model::ListContractualInvestmentsOutcome ListContractualInvestments(
      const Model::ListContractualInvestmentsRequest& request) const;
 
  template <typename ListContractualInvestmentsRequestT = Model::ListContractualInvestmentsRequest>
  Model::ListContractualInvestmentsOutcomeCallable ListContractualInvestmentsCallable(
      const ListContractualInvestmentsRequestT& request) const {
    return SubmitCallable(&BillingClient::ListContractualInvestments, request);
  }
 
  template <typename ListContractualInvestmentsRequestT = Model::ListContractualInvestmentsRequest>
  void ListContractualInvestmentsAsync(const ListContractualInvestmentsRequestT& request,
                                       const ListContractualInvestmentsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::ListContractualInvestments, request, handler, context);
  }
 
  virtual Model::ListEnterpriseSupportLinkedAccountChargesOutcome ListEnterpriseSupportLinkedAccountCharges(
      const Model::ListEnterpriseSupportLinkedAccountChargesRequest& request) const;
 
  template <typename ListEnterpriseSupportLinkedAccountChargesRequestT = Model::ListEnterpriseSupportLinkedAccountChargesRequest>
  Model::ListEnterpriseSupportLinkedAccountChargesOutcomeCallable ListEnterpriseSupportLinkedAccountChargesCallable(
      const ListEnterpriseSupportLinkedAccountChargesRequestT& request) const {
    return SubmitCallable(&BillingClient::ListEnterpriseSupportLinkedAccountCharges, request);
  }
 
  template <typename ListEnterpriseSupportLinkedAccountChargesRequestT = Model::ListEnterpriseSupportLinkedAccountChargesRequest>
  void ListEnterpriseSupportLinkedAccountChargesAsync(
      const ListEnterpriseSupportLinkedAccountChargesRequestT& request,
      const ListEnterpriseSupportLinkedAccountChargesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::ListEnterpriseSupportLinkedAccountCharges, request, handler, context);
  }
 
  virtual Model::ListSourceViewsForBillingViewOutcome ListSourceViewsForBillingView(
      const Model::ListSourceViewsForBillingViewRequest& request) const;
 
  template <typename ListSourceViewsForBillingViewRequestT = Model::ListSourceViewsForBillingViewRequest>
  Model::ListSourceViewsForBillingViewOutcomeCallable ListSourceViewsForBillingViewCallable(
      const ListSourceViewsForBillingViewRequestT& request) const {
    return SubmitCallable(&BillingClient::ListSourceViewsForBillingView, request);
  }
 
  template <typename ListSourceViewsForBillingViewRequestT = Model::ListSourceViewsForBillingViewRequest>
  void ListSourceViewsForBillingViewAsync(const ListSourceViewsForBillingViewRequestT& request,
                                          const ListSourceViewsForBillingViewResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::ListSourceViewsForBillingView, 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(&BillingClient::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(&BillingClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RedeemCreditsOutcome RedeemCredits(const Model::RedeemCreditsRequest& request) const;
 
  template <typename RedeemCreditsRequestT = Model::RedeemCreditsRequest>
  Model::RedeemCreditsOutcomeCallable RedeemCreditsCallable(const RedeemCreditsRequestT& request) const {
    return SubmitCallable(&BillingClient::RedeemCredits, request);
  }
 
  template <typename RedeemCreditsRequestT = Model::RedeemCreditsRequest>
  void RedeemCreditsAsync(const RedeemCreditsRequestT& request, const RedeemCreditsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::RedeemCredits, 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(&BillingClient::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(&BillingClient::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(&BillingClient::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(&BillingClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateBillingPreferencesOutcome UpdateBillingPreferences(const Model::UpdateBillingPreferencesRequest& request) const;
 
  template <typename UpdateBillingPreferencesRequestT = Model::UpdateBillingPreferencesRequest>
  Model::UpdateBillingPreferencesOutcomeCallable UpdateBillingPreferencesCallable(const UpdateBillingPreferencesRequestT& request) const {
    return SubmitCallable(&BillingClient::UpdateBillingPreferences, request);
  }
 
  template <typename UpdateBillingPreferencesRequestT = Model::UpdateBillingPreferencesRequest>
  void UpdateBillingPreferencesAsync(const UpdateBillingPreferencesRequestT& request,
                                     const UpdateBillingPreferencesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::UpdateBillingPreferences, request, handler, context);
  }
 
  virtual Model::UpdateBillingViewOutcome UpdateBillingView(const Model::UpdateBillingViewRequest& request) const;
 
  template <typename UpdateBillingViewRequestT = Model::UpdateBillingViewRequest>
  Model::UpdateBillingViewOutcomeCallable UpdateBillingViewCallable(const UpdateBillingViewRequestT& request) const {
    return SubmitCallable(&BillingClient::UpdateBillingView, request);
  }
 
  template <typename UpdateBillingViewRequestT = Model::UpdateBillingViewRequest>
  void UpdateBillingViewAsync(const UpdateBillingViewRequestT& request, const UpdateBillingViewResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BillingClient::UpdateBillingView, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<BillingEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<BillingClient>;
  void init(const BillingClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, BillingError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  BillingClientConfiguration m_clientConfiguration;
  std::shared_ptr<BillingEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Billing
}  // namespace Aws