BillingConductorClient.h

 
#pragma once
#include <aws/billingconductor/BillingConductor_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/billingconductor/BillingConductorServiceClientModel.h>
 
namespace Aws
{
namespace BillingConductor
{
  class AWS_BILLINGCONDUCTOR_API BillingConductorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<BillingConductorClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef BillingConductorClientConfiguration ClientConfigurationType;
      typedef BillingConductorEndpointProvider EndpointProviderType;
 
        BillingConductorClient(const Aws::BillingConductor::BillingConductorClientConfiguration& clientConfiguration = Aws::BillingConductor::BillingConductorClientConfiguration(),
                               std::shared_ptr<BillingConductorEndpointProviderBase> endpointProvider = nullptr);
 
        BillingConductorClient(const Aws::Auth::AWSCredentials& credentials,
                               std::shared_ptr<BillingConductorEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::BillingConductor::BillingConductorClientConfiguration& clientConfiguration = Aws::BillingConductor::BillingConductorClientConfiguration());
 
        BillingConductorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               std::shared_ptr<BillingConductorEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::BillingConductor::BillingConductorClientConfiguration& clientConfiguration = Aws::BillingConductor::BillingConductorClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        BillingConductorClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BillingConductorClient(const Aws::Auth::AWSCredentials& credentials,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BillingConductorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~BillingConductorClient();
 
        virtual Model::AssociateAccountsOutcome AssociateAccounts(const Model::AssociateAccountsRequest& request) const;
 
        template<typename AssociateAccountsRequestT = Model::AssociateAccountsRequest>
        Model::AssociateAccountsOutcomeCallable AssociateAccountsCallable(const AssociateAccountsRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::AssociateAccounts, request);
        }
 
        template<typename AssociateAccountsRequestT = Model::AssociateAccountsRequest>
        void AssociateAccountsAsync(const AssociateAccountsRequestT& request, const AssociateAccountsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::AssociateAccounts, request, handler, context);
        }
 
        virtual Model::AssociatePricingRulesOutcome AssociatePricingRules(const Model::AssociatePricingRulesRequest& request) const;
 
        template<typename AssociatePricingRulesRequestT = Model::AssociatePricingRulesRequest>
        Model::AssociatePricingRulesOutcomeCallable AssociatePricingRulesCallable(const AssociatePricingRulesRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::AssociatePricingRules, request);
        }
 
        template<typename AssociatePricingRulesRequestT = Model::AssociatePricingRulesRequest>
        void AssociatePricingRulesAsync(const AssociatePricingRulesRequestT& request, const AssociatePricingRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::AssociatePricingRules, request, handler, context);
        }
 
        virtual Model::BatchAssociateResourcesToCustomLineItemOutcome BatchAssociateResourcesToCustomLineItem(const Model::BatchAssociateResourcesToCustomLineItemRequest& request) const;
 
        template<typename BatchAssociateResourcesToCustomLineItemRequestT = Model::BatchAssociateResourcesToCustomLineItemRequest>
        Model::BatchAssociateResourcesToCustomLineItemOutcomeCallable BatchAssociateResourcesToCustomLineItemCallable(const BatchAssociateResourcesToCustomLineItemRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::BatchAssociateResourcesToCustomLineItem, request);
        }
 
        template<typename BatchAssociateResourcesToCustomLineItemRequestT = Model::BatchAssociateResourcesToCustomLineItemRequest>
        void BatchAssociateResourcesToCustomLineItemAsync(const BatchAssociateResourcesToCustomLineItemRequestT& request, const BatchAssociateResourcesToCustomLineItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::BatchAssociateResourcesToCustomLineItem, request, handler, context);
        }
 
        virtual Model::BatchDisassociateResourcesFromCustomLineItemOutcome BatchDisassociateResourcesFromCustomLineItem(const Model::BatchDisassociateResourcesFromCustomLineItemRequest& request) const;
 
        template<typename BatchDisassociateResourcesFromCustomLineItemRequestT = Model::BatchDisassociateResourcesFromCustomLineItemRequest>
        Model::BatchDisassociateResourcesFromCustomLineItemOutcomeCallable BatchDisassociateResourcesFromCustomLineItemCallable(const BatchDisassociateResourcesFromCustomLineItemRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::BatchDisassociateResourcesFromCustomLineItem, request);
        }
 
        template<typename BatchDisassociateResourcesFromCustomLineItemRequestT = Model::BatchDisassociateResourcesFromCustomLineItemRequest>
        void BatchDisassociateResourcesFromCustomLineItemAsync(const BatchDisassociateResourcesFromCustomLineItemRequestT& request, const BatchDisassociateResourcesFromCustomLineItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::BatchDisassociateResourcesFromCustomLineItem, request, handler, context);
        }
 
        virtual Model::CreateBillingGroupOutcome CreateBillingGroup(const Model::CreateBillingGroupRequest& request) const;
 
        template<typename CreateBillingGroupRequestT = Model::CreateBillingGroupRequest>
        Model::CreateBillingGroupOutcomeCallable CreateBillingGroupCallable(const CreateBillingGroupRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::CreateBillingGroup, request);
        }
 
        template<typename CreateBillingGroupRequestT = Model::CreateBillingGroupRequest>
        void CreateBillingGroupAsync(const CreateBillingGroupRequestT& request, const CreateBillingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::CreateBillingGroup, request, handler, context);
        }
 
        virtual Model::CreateCustomLineItemOutcome CreateCustomLineItem(const Model::CreateCustomLineItemRequest& request) const;
 
        template<typename CreateCustomLineItemRequestT = Model::CreateCustomLineItemRequest>
        Model::CreateCustomLineItemOutcomeCallable CreateCustomLineItemCallable(const CreateCustomLineItemRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::CreateCustomLineItem, request);
        }
 
        template<typename CreateCustomLineItemRequestT = Model::CreateCustomLineItemRequest>
        void CreateCustomLineItemAsync(const CreateCustomLineItemRequestT& request, const CreateCustomLineItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::CreateCustomLineItem, request, handler, context);
        }
 
        virtual Model::CreatePricingPlanOutcome CreatePricingPlan(const Model::CreatePricingPlanRequest& request) const;
 
        template<typename CreatePricingPlanRequestT = Model::CreatePricingPlanRequest>
        Model::CreatePricingPlanOutcomeCallable CreatePricingPlanCallable(const CreatePricingPlanRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::CreatePricingPlan, request);
        }
 
        template<typename CreatePricingPlanRequestT = Model::CreatePricingPlanRequest>
        void CreatePricingPlanAsync(const CreatePricingPlanRequestT& request, const CreatePricingPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::CreatePricingPlan, request, handler, context);
        }
 
        virtual Model::CreatePricingRuleOutcome CreatePricingRule(const Model::CreatePricingRuleRequest& request) const;
 
        template<typename CreatePricingRuleRequestT = Model::CreatePricingRuleRequest>
        Model::CreatePricingRuleOutcomeCallable CreatePricingRuleCallable(const CreatePricingRuleRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::CreatePricingRule, request);
        }
 
        template<typename CreatePricingRuleRequestT = Model::CreatePricingRuleRequest>
        void CreatePricingRuleAsync(const CreatePricingRuleRequestT& request, const CreatePricingRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::CreatePricingRule, request, handler, context);
        }
 
        virtual Model::DeleteBillingGroupOutcome DeleteBillingGroup(const Model::DeleteBillingGroupRequest& request) const;
 
        template<typename DeleteBillingGroupRequestT = Model::DeleteBillingGroupRequest>
        Model::DeleteBillingGroupOutcomeCallable DeleteBillingGroupCallable(const DeleteBillingGroupRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::DeleteBillingGroup, request);
        }
 
        template<typename DeleteBillingGroupRequestT = Model::DeleteBillingGroupRequest>
        void DeleteBillingGroupAsync(const DeleteBillingGroupRequestT& request, const DeleteBillingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::DeleteBillingGroup, request, handler, context);
        }
 
        virtual Model::DeleteCustomLineItemOutcome DeleteCustomLineItem(const Model::DeleteCustomLineItemRequest& request) const;
 
        template<typename DeleteCustomLineItemRequestT = Model::DeleteCustomLineItemRequest>
        Model::DeleteCustomLineItemOutcomeCallable DeleteCustomLineItemCallable(const DeleteCustomLineItemRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::DeleteCustomLineItem, request);
        }
 
        template<typename DeleteCustomLineItemRequestT = Model::DeleteCustomLineItemRequest>
        void DeleteCustomLineItemAsync(const DeleteCustomLineItemRequestT& request, const DeleteCustomLineItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::DeleteCustomLineItem, request, handler, context);
        }
 
        virtual Model::DeletePricingPlanOutcome DeletePricingPlan(const Model::DeletePricingPlanRequest& request) const;
 
        template<typename DeletePricingPlanRequestT = Model::DeletePricingPlanRequest>
        Model::DeletePricingPlanOutcomeCallable DeletePricingPlanCallable(const DeletePricingPlanRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::DeletePricingPlan, request);
        }
 
        template<typename DeletePricingPlanRequestT = Model::DeletePricingPlanRequest>
        void DeletePricingPlanAsync(const DeletePricingPlanRequestT& request, const DeletePricingPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::DeletePricingPlan, request, handler, context);
        }
 
        virtual Model::DeletePricingRuleOutcome DeletePricingRule(const Model::DeletePricingRuleRequest& request) const;
 
        template<typename DeletePricingRuleRequestT = Model::DeletePricingRuleRequest>
        Model::DeletePricingRuleOutcomeCallable DeletePricingRuleCallable(const DeletePricingRuleRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::DeletePricingRule, request);
        }
 
        template<typename DeletePricingRuleRequestT = Model::DeletePricingRuleRequest>
        void DeletePricingRuleAsync(const DeletePricingRuleRequestT& request, const DeletePricingRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::DeletePricingRule, request, handler, context);
        }
 
        virtual Model::DisassociateAccountsOutcome DisassociateAccounts(const Model::DisassociateAccountsRequest& request) const;
 
        template<typename DisassociateAccountsRequestT = Model::DisassociateAccountsRequest>
        Model::DisassociateAccountsOutcomeCallable DisassociateAccountsCallable(const DisassociateAccountsRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::DisassociateAccounts, request);
        }
 
        template<typename DisassociateAccountsRequestT = Model::DisassociateAccountsRequest>
        void DisassociateAccountsAsync(const DisassociateAccountsRequestT& request, const DisassociateAccountsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::DisassociateAccounts, request, handler, context);
        }
 
        virtual Model::DisassociatePricingRulesOutcome DisassociatePricingRules(const Model::DisassociatePricingRulesRequest& request) const;
 
        template<typename DisassociatePricingRulesRequestT = Model::DisassociatePricingRulesRequest>
        Model::DisassociatePricingRulesOutcomeCallable DisassociatePricingRulesCallable(const DisassociatePricingRulesRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::DisassociatePricingRules, request);
        }
 
        template<typename DisassociatePricingRulesRequestT = Model::DisassociatePricingRulesRequest>
        void DisassociatePricingRulesAsync(const DisassociatePricingRulesRequestT& request, const DisassociatePricingRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::DisassociatePricingRules, request, handler, context);
        }
 
        virtual Model::GetBillingGroupCostReportOutcome GetBillingGroupCostReport(const Model::GetBillingGroupCostReportRequest& request) const;
 
        template<typename GetBillingGroupCostReportRequestT = Model::GetBillingGroupCostReportRequest>
        Model::GetBillingGroupCostReportOutcomeCallable GetBillingGroupCostReportCallable(const GetBillingGroupCostReportRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::GetBillingGroupCostReport, request);
        }
 
        template<typename GetBillingGroupCostReportRequestT = Model::GetBillingGroupCostReportRequest>
        void GetBillingGroupCostReportAsync(const GetBillingGroupCostReportRequestT& request, const GetBillingGroupCostReportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::GetBillingGroupCostReport, request, handler, context);
        }
 
        virtual Model::ListAccountAssociationsOutcome ListAccountAssociations(const Model::ListAccountAssociationsRequest& request = {}) const;
 
        template<typename ListAccountAssociationsRequestT = Model::ListAccountAssociationsRequest>
        Model::ListAccountAssociationsOutcomeCallable ListAccountAssociationsCallable(const ListAccountAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&BillingConductorClient::ListAccountAssociations, request);
        }
 
        template<typename ListAccountAssociationsRequestT = Model::ListAccountAssociationsRequest>
        void ListAccountAssociationsAsync(const ListAccountAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccountAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&BillingConductorClient::ListAccountAssociations, request, handler, context);
        }
 
        virtual Model::ListBillingGroupCostReportsOutcome ListBillingGroupCostReports(const Model::ListBillingGroupCostReportsRequest& request = {}) const;
 
        template<typename ListBillingGroupCostReportsRequestT = Model::ListBillingGroupCostReportsRequest>
        Model::ListBillingGroupCostReportsOutcomeCallable ListBillingGroupCostReportsCallable(const ListBillingGroupCostReportsRequestT& request = {}) const
        {
            return SubmitCallable(&BillingConductorClient::ListBillingGroupCostReports, request);
        }
 
        template<typename ListBillingGroupCostReportsRequestT = Model::ListBillingGroupCostReportsRequest>
        void ListBillingGroupCostReportsAsync(const ListBillingGroupCostReportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBillingGroupCostReportsRequestT& request = {}) const
        {
            return SubmitAsync(&BillingConductorClient::ListBillingGroupCostReports, request, handler, context);
        }
 
        virtual Model::ListBillingGroupsOutcome ListBillingGroups(const Model::ListBillingGroupsRequest& request = {}) const;
 
        template<typename ListBillingGroupsRequestT = Model::ListBillingGroupsRequest>
        Model::ListBillingGroupsOutcomeCallable ListBillingGroupsCallable(const ListBillingGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&BillingConductorClient::ListBillingGroups, request);
        }
 
        template<typename ListBillingGroupsRequestT = Model::ListBillingGroupsRequest>
        void ListBillingGroupsAsync(const ListBillingGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListBillingGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&BillingConductorClient::ListBillingGroups, request, handler, context);
        }
 
        virtual Model::ListCustomLineItemVersionsOutcome ListCustomLineItemVersions(const Model::ListCustomLineItemVersionsRequest& request) const;
 
        template<typename ListCustomLineItemVersionsRequestT = Model::ListCustomLineItemVersionsRequest>
        Model::ListCustomLineItemVersionsOutcomeCallable ListCustomLineItemVersionsCallable(const ListCustomLineItemVersionsRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::ListCustomLineItemVersions, request);
        }
 
        template<typename ListCustomLineItemVersionsRequestT = Model::ListCustomLineItemVersionsRequest>
        void ListCustomLineItemVersionsAsync(const ListCustomLineItemVersionsRequestT& request, const ListCustomLineItemVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::ListCustomLineItemVersions, request, handler, context);
        }
 
        virtual Model::ListCustomLineItemsOutcome ListCustomLineItems(const Model::ListCustomLineItemsRequest& request = {}) const;
 
        template<typename ListCustomLineItemsRequestT = Model::ListCustomLineItemsRequest>
        Model::ListCustomLineItemsOutcomeCallable ListCustomLineItemsCallable(const ListCustomLineItemsRequestT& request = {}) const
        {
            return SubmitCallable(&BillingConductorClient::ListCustomLineItems, request);
        }
 
        template<typename ListCustomLineItemsRequestT = Model::ListCustomLineItemsRequest>
        void ListCustomLineItemsAsync(const ListCustomLineItemsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCustomLineItemsRequestT& request = {}) const
        {
            return SubmitAsync(&BillingConductorClient::ListCustomLineItems, request, handler, context);
        }
 
        virtual Model::ListPricingPlansOutcome ListPricingPlans(const Model::ListPricingPlansRequest& request = {}) const;
 
        template<typename ListPricingPlansRequestT = Model::ListPricingPlansRequest>
        Model::ListPricingPlansOutcomeCallable ListPricingPlansCallable(const ListPricingPlansRequestT& request = {}) const
        {
            return SubmitCallable(&BillingConductorClient::ListPricingPlans, request);
        }
 
        template<typename ListPricingPlansRequestT = Model::ListPricingPlansRequest>
        void ListPricingPlansAsync(const ListPricingPlansResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPricingPlansRequestT& request = {}) const
        {
            return SubmitAsync(&BillingConductorClient::ListPricingPlans, request, handler, context);
        }
 
        virtual Model::ListPricingPlansAssociatedWithPricingRuleOutcome ListPricingPlansAssociatedWithPricingRule(const Model::ListPricingPlansAssociatedWithPricingRuleRequest& request) const;
 
        template<typename ListPricingPlansAssociatedWithPricingRuleRequestT = Model::ListPricingPlansAssociatedWithPricingRuleRequest>
        Model::ListPricingPlansAssociatedWithPricingRuleOutcomeCallable ListPricingPlansAssociatedWithPricingRuleCallable(const ListPricingPlansAssociatedWithPricingRuleRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::ListPricingPlansAssociatedWithPricingRule, request);
        }
 
        template<typename ListPricingPlansAssociatedWithPricingRuleRequestT = Model::ListPricingPlansAssociatedWithPricingRuleRequest>
        void ListPricingPlansAssociatedWithPricingRuleAsync(const ListPricingPlansAssociatedWithPricingRuleRequestT& request, const ListPricingPlansAssociatedWithPricingRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::ListPricingPlansAssociatedWithPricingRule, request, handler, context);
        }
 
        virtual Model::ListPricingRulesOutcome ListPricingRules(const Model::ListPricingRulesRequest& request = {}) const;
 
        template<typename ListPricingRulesRequestT = Model::ListPricingRulesRequest>
        Model::ListPricingRulesOutcomeCallable ListPricingRulesCallable(const ListPricingRulesRequestT& request = {}) const
        {
            return SubmitCallable(&BillingConductorClient::ListPricingRules, request);
        }
 
        template<typename ListPricingRulesRequestT = Model::ListPricingRulesRequest>
        void ListPricingRulesAsync(const ListPricingRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPricingRulesRequestT& request = {}) const
        {
            return SubmitAsync(&BillingConductorClient::ListPricingRules, request, handler, context);
        }
 
        virtual Model::ListPricingRulesAssociatedToPricingPlanOutcome ListPricingRulesAssociatedToPricingPlan(const Model::ListPricingRulesAssociatedToPricingPlanRequest& request) const;
 
        template<typename ListPricingRulesAssociatedToPricingPlanRequestT = Model::ListPricingRulesAssociatedToPricingPlanRequest>
        Model::ListPricingRulesAssociatedToPricingPlanOutcomeCallable ListPricingRulesAssociatedToPricingPlanCallable(const ListPricingRulesAssociatedToPricingPlanRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::ListPricingRulesAssociatedToPricingPlan, request);
        }
 
        template<typename ListPricingRulesAssociatedToPricingPlanRequestT = Model::ListPricingRulesAssociatedToPricingPlanRequest>
        void ListPricingRulesAssociatedToPricingPlanAsync(const ListPricingRulesAssociatedToPricingPlanRequestT& request, const ListPricingRulesAssociatedToPricingPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::ListPricingRulesAssociatedToPricingPlan, request, handler, context);
        }
 
        virtual Model::ListResourcesAssociatedToCustomLineItemOutcome ListResourcesAssociatedToCustomLineItem(const Model::ListResourcesAssociatedToCustomLineItemRequest& request) const;
 
        template<typename ListResourcesAssociatedToCustomLineItemRequestT = Model::ListResourcesAssociatedToCustomLineItemRequest>
        Model::ListResourcesAssociatedToCustomLineItemOutcomeCallable ListResourcesAssociatedToCustomLineItemCallable(const ListResourcesAssociatedToCustomLineItemRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::ListResourcesAssociatedToCustomLineItem, request);
        }
 
        template<typename ListResourcesAssociatedToCustomLineItemRequestT = Model::ListResourcesAssociatedToCustomLineItemRequest>
        void ListResourcesAssociatedToCustomLineItemAsync(const ListResourcesAssociatedToCustomLineItemRequestT& request, const ListResourcesAssociatedToCustomLineItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::ListResourcesAssociatedToCustomLineItem, 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(&BillingConductorClient::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(&BillingConductorClient::ListTagsForResource, 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(&BillingConductorClient::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(&BillingConductorClient::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(&BillingConductorClient::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(&BillingConductorClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateBillingGroupOutcome UpdateBillingGroup(const Model::UpdateBillingGroupRequest& request) const;
 
        template<typename UpdateBillingGroupRequestT = Model::UpdateBillingGroupRequest>
        Model::UpdateBillingGroupOutcomeCallable UpdateBillingGroupCallable(const UpdateBillingGroupRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::UpdateBillingGroup, request);
        }
 
        template<typename UpdateBillingGroupRequestT = Model::UpdateBillingGroupRequest>
        void UpdateBillingGroupAsync(const UpdateBillingGroupRequestT& request, const UpdateBillingGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::UpdateBillingGroup, request, handler, context);
        }
 
        virtual Model::UpdateCustomLineItemOutcome UpdateCustomLineItem(const Model::UpdateCustomLineItemRequest& request) const;
 
        template<typename UpdateCustomLineItemRequestT = Model::UpdateCustomLineItemRequest>
        Model::UpdateCustomLineItemOutcomeCallable UpdateCustomLineItemCallable(const UpdateCustomLineItemRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::UpdateCustomLineItem, request);
        }
 
        template<typename UpdateCustomLineItemRequestT = Model::UpdateCustomLineItemRequest>
        void UpdateCustomLineItemAsync(const UpdateCustomLineItemRequestT& request, const UpdateCustomLineItemResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::UpdateCustomLineItem, request, handler, context);
        }
 
        virtual Model::UpdatePricingPlanOutcome UpdatePricingPlan(const Model::UpdatePricingPlanRequest& request) const;
 
        template<typename UpdatePricingPlanRequestT = Model::UpdatePricingPlanRequest>
        Model::UpdatePricingPlanOutcomeCallable UpdatePricingPlanCallable(const UpdatePricingPlanRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::UpdatePricingPlan, request);
        }
 
        template<typename UpdatePricingPlanRequestT = Model::UpdatePricingPlanRequest>
        void UpdatePricingPlanAsync(const UpdatePricingPlanRequestT& request, const UpdatePricingPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::UpdatePricingPlan, request, handler, context);
        }
 
        virtual Model::UpdatePricingRuleOutcome UpdatePricingRule(const Model::UpdatePricingRuleRequest& request) const;
 
        template<typename UpdatePricingRuleRequestT = Model::UpdatePricingRuleRequest>
        Model::UpdatePricingRuleOutcomeCallable UpdatePricingRuleCallable(const UpdatePricingRuleRequestT& request) const
        {
            return SubmitCallable(&BillingConductorClient::UpdatePricingRule, request);
        }
 
        template<typename UpdatePricingRuleRequestT = Model::UpdatePricingRuleRequest>
        void UpdatePricingRuleAsync(const UpdatePricingRuleRequestT& request, const UpdatePricingRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BillingConductorClient::UpdatePricingRule, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BillingConductorEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BillingConductorClient>;
      void init(const BillingConductorClientConfiguration& clientConfiguration);
 
      BillingConductorClientConfiguration m_clientConfiguration;
      std::shared_ptr<BillingConductorEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace BillingConductor
} // namespace Aws