BillingClient.h

 
#pragma once
#include <aws/billing/Billing_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/billing/BillingServiceClientModel.h>
 
namespace Aws
{
namespace Billing
{
  class AWS_BILLING_API BillingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BillingEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BillingClient>;
      void init(const BillingClientConfiguration& clientConfiguration);
 
      BillingClientConfiguration m_clientConfiguration;
      std::shared_ptr<BillingEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Billing
} // namespace Aws