InvoicingClient.h

 
#pragma once
#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>
#include <aws/invoicing/InvoicingPaginationBase.h>
#include <aws/invoicing/InvoicingServiceClientModel.h>
#include <aws/invoicing/InvoicingWaiter.h>
#include <aws/invoicing/Invoicing_EXPORTS.h>
 
namespace Aws {
namespace Invoicing {
class AWS_INVOICING_API InvoicingClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<InvoicingClient>,
                                          public InvoicingPaginationBase<InvoicingClient>,
                                          public InvoicingWaiter<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::CreateProcurementPortalPreferenceOutcome CreateProcurementPortalPreference(
      const Model::CreateProcurementPortalPreferenceRequest& request) const;
 
  template <typename CreateProcurementPortalPreferenceRequestT = Model::CreateProcurementPortalPreferenceRequest>
  Model::CreateProcurementPortalPreferenceOutcomeCallable CreateProcurementPortalPreferenceCallable(
      const CreateProcurementPortalPreferenceRequestT& request) const {
    return SubmitCallable(&InvoicingClient::CreateProcurementPortalPreference, request);
  }
 
  template <typename CreateProcurementPortalPreferenceRequestT = Model::CreateProcurementPortalPreferenceRequest>
  void CreateProcurementPortalPreferenceAsync(const CreateProcurementPortalPreferenceRequestT& request,
                                              const CreateProcurementPortalPreferenceResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InvoicingClient::CreateProcurementPortalPreference, 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::DeleteProcurementPortalPreferenceOutcome DeleteProcurementPortalPreference(
      const Model::DeleteProcurementPortalPreferenceRequest& request) const;
 
  template <typename DeleteProcurementPortalPreferenceRequestT = Model::DeleteProcurementPortalPreferenceRequest>
  Model::DeleteProcurementPortalPreferenceOutcomeCallable DeleteProcurementPortalPreferenceCallable(
      const DeleteProcurementPortalPreferenceRequestT& request) const {
    return SubmitCallable(&InvoicingClient::DeleteProcurementPortalPreference, request);
  }
 
  template <typename DeleteProcurementPortalPreferenceRequestT = Model::DeleteProcurementPortalPreferenceRequest>
  void DeleteProcurementPortalPreferenceAsync(const DeleteProcurementPortalPreferenceRequestT& request,
                                              const DeleteProcurementPortalPreferenceResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InvoicingClient::DeleteProcurementPortalPreference, request, handler, context);
  }
 
  virtual Model::GetInvoicePDFOutcome GetInvoicePDF(const Model::GetInvoicePDFRequest& request) const;
 
  template <typename GetInvoicePDFRequestT = Model::GetInvoicePDFRequest>
  Model::GetInvoicePDFOutcomeCallable GetInvoicePDFCallable(const GetInvoicePDFRequestT& request) const {
    return SubmitCallable(&InvoicingClient::GetInvoicePDF, request);
  }
 
  template <typename GetInvoicePDFRequestT = Model::GetInvoicePDFRequest>
  void GetInvoicePDFAsync(const GetInvoicePDFRequestT& request, const GetInvoicePDFResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InvoicingClient::GetInvoicePDF, 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::GetProcurementPortalPreferenceOutcome GetProcurementPortalPreference(
      const Model::GetProcurementPortalPreferenceRequest& request) const;
 
  template <typename GetProcurementPortalPreferenceRequestT = Model::GetProcurementPortalPreferenceRequest>
  Model::GetProcurementPortalPreferenceOutcomeCallable GetProcurementPortalPreferenceCallable(
      const GetProcurementPortalPreferenceRequestT& request) const {
    return SubmitCallable(&InvoicingClient::GetProcurementPortalPreference, request);
  }
 
  template <typename GetProcurementPortalPreferenceRequestT = Model::GetProcurementPortalPreferenceRequest>
  void GetProcurementPortalPreferenceAsync(const GetProcurementPortalPreferenceRequestT& request,
                                           const GetProcurementPortalPreferenceResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InvoicingClient::GetProcurementPortalPreference, 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::ListProcurementPortalPreferencesOutcome ListProcurementPortalPreferences(
      const Model::ListProcurementPortalPreferencesRequest& request = {}) const;
 
  template <typename ListProcurementPortalPreferencesRequestT = Model::ListProcurementPortalPreferencesRequest>
  Model::ListProcurementPortalPreferencesOutcomeCallable ListProcurementPortalPreferencesCallable(
      const ListProcurementPortalPreferencesRequestT& request = {}) const {
    return SubmitCallable(&InvoicingClient::ListProcurementPortalPreferences, request);
  }
 
  template <typename ListProcurementPortalPreferencesRequestT = Model::ListProcurementPortalPreferencesRequest>
  void ListProcurementPortalPreferencesAsync(const ListProcurementPortalPreferencesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const ListProcurementPortalPreferencesRequestT& request = {}) const {
    return SubmitAsync(&InvoicingClient::ListProcurementPortalPreferences, 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::PutProcurementPortalPreferenceOutcome PutProcurementPortalPreference(
      const Model::PutProcurementPortalPreferenceRequest& request) const;
 
  template <typename PutProcurementPortalPreferenceRequestT = Model::PutProcurementPortalPreferenceRequest>
  Model::PutProcurementPortalPreferenceOutcomeCallable PutProcurementPortalPreferenceCallable(
      const PutProcurementPortalPreferenceRequestT& request) const {
    return SubmitCallable(&InvoicingClient::PutProcurementPortalPreference, request);
  }
 
  template <typename PutProcurementPortalPreferenceRequestT = Model::PutProcurementPortalPreferenceRequest>
  void PutProcurementPortalPreferenceAsync(const PutProcurementPortalPreferenceRequestT& request,
                                           const PutProcurementPortalPreferenceResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InvoicingClient::PutProcurementPortalPreference, 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);
  }
 
  virtual Model::UpdateProcurementPortalPreferenceStatusOutcome UpdateProcurementPortalPreferenceStatus(
      const Model::UpdateProcurementPortalPreferenceStatusRequest& request) const;
 
  template <typename UpdateProcurementPortalPreferenceStatusRequestT = Model::UpdateProcurementPortalPreferenceStatusRequest>
  Model::UpdateProcurementPortalPreferenceStatusOutcomeCallable UpdateProcurementPortalPreferenceStatusCallable(
      const UpdateProcurementPortalPreferenceStatusRequestT& request) const {
    return SubmitCallable(&InvoicingClient::UpdateProcurementPortalPreferenceStatus, request);
  }
 
  template <typename UpdateProcurementPortalPreferenceStatusRequestT = Model::UpdateProcurementPortalPreferenceStatusRequest>
  void UpdateProcurementPortalPreferenceStatusAsync(const UpdateProcurementPortalPreferenceStatusRequestT& request,
                                                    const UpdateProcurementPortalPreferenceStatusResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&InvoicingClient::UpdateProcurementPortalPreferenceStatus, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<InvoicingEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<InvoicingClient>;
  void init(const InvoicingClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, InvoicingError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  InvoicingClientConfiguration m_clientConfiguration;
  std::shared_ptr<InvoicingEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Invoicing
}  // namespace Aws