InvoicingClient.h

 
#pragma once
#include <aws/invoicing/Invoicing_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/invoicing/InvoicingServiceClientModel.h>
 
namespace Aws
{
namespace Invoicing
{
  class AWS_INVOICING_API InvoicingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<InvoicingClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef InvoicingClientConfiguration ClientConfigurationType;
      typedef InvoicingEndpointProvider EndpointProviderType;
 
        InvoicingClient(const Aws::Invoicing::InvoicingClientConfiguration& clientConfiguration = Aws::Invoicing::InvoicingClientConfiguration(),
                        std::shared_ptr<InvoicingEndpointProviderBase> endpointProvider = nullptr);
 
        InvoicingClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<InvoicingEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::Invoicing::InvoicingClientConfiguration& clientConfiguration = Aws::Invoicing::InvoicingClientConfiguration());
 
        InvoicingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<InvoicingEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::Invoicing::InvoicingClientConfiguration& clientConfiguration = Aws::Invoicing::InvoicingClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        InvoicingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        InvoicingClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        InvoicingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~InvoicingClient();
 
        virtual Model::BatchGetInvoiceProfileOutcome BatchGetInvoiceProfile(const Model::BatchGetInvoiceProfileRequest& request) const;
 
        template<typename BatchGetInvoiceProfileRequestT = Model::BatchGetInvoiceProfileRequest>
        Model::BatchGetInvoiceProfileOutcomeCallable BatchGetInvoiceProfileCallable(const BatchGetInvoiceProfileRequestT& request) const
        {
            return SubmitCallable(&InvoicingClient::BatchGetInvoiceProfile, request);
        }
 
        template<typename BatchGetInvoiceProfileRequestT = Model::BatchGetInvoiceProfileRequest>
        void BatchGetInvoiceProfileAsync(const BatchGetInvoiceProfileRequestT& request, const BatchGetInvoiceProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InvoicingClient::BatchGetInvoiceProfile, request, handler, context);
        }
 
        virtual Model::CreateInvoiceUnitOutcome CreateInvoiceUnit(const Model::CreateInvoiceUnitRequest& request) const;
 
        template<typename CreateInvoiceUnitRequestT = Model::CreateInvoiceUnitRequest>
        Model::CreateInvoiceUnitOutcomeCallable CreateInvoiceUnitCallable(const CreateInvoiceUnitRequestT& request) const
        {
            return SubmitCallable(&InvoicingClient::CreateInvoiceUnit, request);
        }
 
        template<typename CreateInvoiceUnitRequestT = Model::CreateInvoiceUnitRequest>
        void CreateInvoiceUnitAsync(const CreateInvoiceUnitRequestT& request, const CreateInvoiceUnitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InvoicingClient::CreateInvoiceUnit, request, handler, context);
        }
 
        virtual Model::DeleteInvoiceUnitOutcome DeleteInvoiceUnit(const Model::DeleteInvoiceUnitRequest& request) const;
 
        template<typename DeleteInvoiceUnitRequestT = Model::DeleteInvoiceUnitRequest>
        Model::DeleteInvoiceUnitOutcomeCallable DeleteInvoiceUnitCallable(const DeleteInvoiceUnitRequestT& request) const
        {
            return SubmitCallable(&InvoicingClient::DeleteInvoiceUnit, request);
        }
 
        template<typename DeleteInvoiceUnitRequestT = Model::DeleteInvoiceUnitRequest>
        void DeleteInvoiceUnitAsync(const DeleteInvoiceUnitRequestT& request, const DeleteInvoiceUnitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InvoicingClient::DeleteInvoiceUnit, request, handler, context);
        }
 
        virtual Model::GetInvoiceUnitOutcome GetInvoiceUnit(const Model::GetInvoiceUnitRequest& request) const;
 
        template<typename GetInvoiceUnitRequestT = Model::GetInvoiceUnitRequest>
        Model::GetInvoiceUnitOutcomeCallable GetInvoiceUnitCallable(const GetInvoiceUnitRequestT& request) const
        {
            return SubmitCallable(&InvoicingClient::GetInvoiceUnit, request);
        }
 
        template<typename GetInvoiceUnitRequestT = Model::GetInvoiceUnitRequest>
        void GetInvoiceUnitAsync(const GetInvoiceUnitRequestT& request, const GetInvoiceUnitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InvoicingClient::GetInvoiceUnit, request, handler, context);
        }
 
        virtual Model::ListInvoiceSummariesOutcome ListInvoiceSummaries(const Model::ListInvoiceSummariesRequest& request) const;
 
        template<typename ListInvoiceSummariesRequestT = Model::ListInvoiceSummariesRequest>
        Model::ListInvoiceSummariesOutcomeCallable ListInvoiceSummariesCallable(const ListInvoiceSummariesRequestT& request) const
        {
            return SubmitCallable(&InvoicingClient::ListInvoiceSummaries, request);
        }
 
        template<typename ListInvoiceSummariesRequestT = Model::ListInvoiceSummariesRequest>
        void ListInvoiceSummariesAsync(const ListInvoiceSummariesRequestT& request, const ListInvoiceSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InvoicingClient::ListInvoiceSummaries, request, handler, context);
        }
 
        virtual Model::ListInvoiceUnitsOutcome ListInvoiceUnits(const Model::ListInvoiceUnitsRequest& request = {}) const;
 
        template<typename ListInvoiceUnitsRequestT = Model::ListInvoiceUnitsRequest>
        Model::ListInvoiceUnitsOutcomeCallable ListInvoiceUnitsCallable(const ListInvoiceUnitsRequestT& request = {}) const
        {
            return SubmitCallable(&InvoicingClient::ListInvoiceUnits, request);
        }
 
        template<typename ListInvoiceUnitsRequestT = Model::ListInvoiceUnitsRequest>
        void ListInvoiceUnitsAsync(const ListInvoiceUnitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInvoiceUnitsRequestT& request = {}) const
        {
            return SubmitAsync(&InvoicingClient::ListInvoiceUnits, 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(&InvoicingClient::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(&InvoicingClient::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(&InvoicingClient::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(&InvoicingClient::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(&InvoicingClient::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(&InvoicingClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateInvoiceUnitOutcome UpdateInvoiceUnit(const Model::UpdateInvoiceUnitRequest& request) const;
 
        template<typename UpdateInvoiceUnitRequestT = Model::UpdateInvoiceUnitRequest>
        Model::UpdateInvoiceUnitOutcomeCallable UpdateInvoiceUnitCallable(const UpdateInvoiceUnitRequestT& request) const
        {
            return SubmitCallable(&InvoicingClient::UpdateInvoiceUnit, request);
        }
 
        template<typename UpdateInvoiceUnitRequestT = Model::UpdateInvoiceUnitRequest>
        void UpdateInvoiceUnitAsync(const UpdateInvoiceUnitRequestT& request, const UpdateInvoiceUnitResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&InvoicingClient::UpdateInvoiceUnit, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<InvoicingEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<InvoicingClient>;
      void init(const InvoicingClientConfiguration& clientConfiguration);
 
      InvoicingClientConfiguration m_clientConfiguration;
      std::shared_ptr<InvoicingEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Invoicing
} // namespace Aws