TaxSettingsClient.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/taxsettings/TaxSettingsPaginationBase.h>
#include <aws/taxsettings/TaxSettingsServiceClientModel.h>
#include <aws/taxsettings/TaxSettings_EXPORTS.h>
 
namespace Aws {
namespace TaxSettings {
class AWS_TAXSETTINGS_API TaxSettingsClient : public Aws::Client::AWSJsonClient,
                                              public Aws::Client::ClientWithAsyncTemplateMethods<TaxSettingsClient>,
                                              public TaxSettingsPaginationBase<TaxSettingsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef TaxSettingsClientConfiguration ClientConfigurationType;
  typedef TaxSettingsEndpointProvider EndpointProviderType;
 
  TaxSettingsClient(
      const Aws::TaxSettings::TaxSettingsClientConfiguration& clientConfiguration = Aws::TaxSettings::TaxSettingsClientConfiguration(),
      std::shared_ptr<TaxSettingsEndpointProviderBase> endpointProvider = nullptr);
 
  TaxSettingsClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<TaxSettingsEndpointProviderBase> endpointProvider = nullptr,
      const Aws::TaxSettings::TaxSettingsClientConfiguration& clientConfiguration = Aws::TaxSettings::TaxSettingsClientConfiguration());
 
  TaxSettingsClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<TaxSettingsEndpointProviderBase> endpointProvider = nullptr,
      const Aws::TaxSettings::TaxSettingsClientConfiguration& clientConfiguration = Aws::TaxSettings::TaxSettingsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  TaxSettingsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TaxSettingsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TaxSettingsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~TaxSettingsClient();
 
  virtual Model::BatchDeleteTaxRegistrationOutcome BatchDeleteTaxRegistration(
      const Model::BatchDeleteTaxRegistrationRequest& request) const;
 
  template <typename BatchDeleteTaxRegistrationRequestT = Model::BatchDeleteTaxRegistrationRequest>
  Model::BatchDeleteTaxRegistrationOutcomeCallable BatchDeleteTaxRegistrationCallable(
      const BatchDeleteTaxRegistrationRequestT& request) const {
    return SubmitCallable(&TaxSettingsClient::BatchDeleteTaxRegistration, request);
  }
 
  template <typename BatchDeleteTaxRegistrationRequestT = Model::BatchDeleteTaxRegistrationRequest>
  void BatchDeleteTaxRegistrationAsync(const BatchDeleteTaxRegistrationRequestT& request,
                                       const BatchDeleteTaxRegistrationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TaxSettingsClient::BatchDeleteTaxRegistration, request, handler, context);
  }
 
  virtual Model::BatchGetTaxExemptionsOutcome BatchGetTaxExemptions(const Model::BatchGetTaxExemptionsRequest& request) const;
 
  template <typename BatchGetTaxExemptionsRequestT = Model::BatchGetTaxExemptionsRequest>
  Model::BatchGetTaxExemptionsOutcomeCallable BatchGetTaxExemptionsCallable(const BatchGetTaxExemptionsRequestT& request) const {
    return SubmitCallable(&TaxSettingsClient::BatchGetTaxExemptions, request);
  }
 
  template <typename BatchGetTaxExemptionsRequestT = Model::BatchGetTaxExemptionsRequest>
  void BatchGetTaxExemptionsAsync(const BatchGetTaxExemptionsRequestT& request, const BatchGetTaxExemptionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TaxSettingsClient::BatchGetTaxExemptions, request, handler, context);
  }
 
  virtual Model::BatchPutTaxRegistrationOutcome BatchPutTaxRegistration(const Model::BatchPutTaxRegistrationRequest& request) const;
 
  template <typename BatchPutTaxRegistrationRequestT = Model::BatchPutTaxRegistrationRequest>
  Model::BatchPutTaxRegistrationOutcomeCallable BatchPutTaxRegistrationCallable(const BatchPutTaxRegistrationRequestT& request) const {
    return SubmitCallable(&TaxSettingsClient::BatchPutTaxRegistration, request);
  }
 
  template <typename BatchPutTaxRegistrationRequestT = Model::BatchPutTaxRegistrationRequest>
  void BatchPutTaxRegistrationAsync(const BatchPutTaxRegistrationRequestT& request,
                                    const BatchPutTaxRegistrationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TaxSettingsClient::BatchPutTaxRegistration, request, handler, context);
  }
 
  virtual Model::DeleteSupplementalTaxRegistrationOutcome DeleteSupplementalTaxRegistration(
      const Model::DeleteSupplementalTaxRegistrationRequest& request) const;
 
  template <typename DeleteSupplementalTaxRegistrationRequestT = Model::DeleteSupplementalTaxRegistrationRequest>
  Model::DeleteSupplementalTaxRegistrationOutcomeCallable DeleteSupplementalTaxRegistrationCallable(
      const DeleteSupplementalTaxRegistrationRequestT& request) const {
    return SubmitCallable(&TaxSettingsClient::DeleteSupplementalTaxRegistration, request);
  }
 
  template <typename DeleteSupplementalTaxRegistrationRequestT = Model::DeleteSupplementalTaxRegistrationRequest>
  void DeleteSupplementalTaxRegistrationAsync(const DeleteSupplementalTaxRegistrationRequestT& request,
                                              const DeleteSupplementalTaxRegistrationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TaxSettingsClient::DeleteSupplementalTaxRegistration, request, handler, context);
  }
 
  virtual Model::DeleteTaxRegistrationOutcome DeleteTaxRegistration(const Model::DeleteTaxRegistrationRequest& request = {}) const;
 
  template <typename DeleteTaxRegistrationRequestT = Model::DeleteTaxRegistrationRequest>
  Model::DeleteTaxRegistrationOutcomeCallable DeleteTaxRegistrationCallable(const DeleteTaxRegistrationRequestT& request = {}) const {
    return SubmitCallable(&TaxSettingsClient::DeleteTaxRegistration, request);
  }
 
  template <typename DeleteTaxRegistrationRequestT = Model::DeleteTaxRegistrationRequest>
  void DeleteTaxRegistrationAsync(const DeleteTaxRegistrationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DeleteTaxRegistrationRequestT& request = {}) const {
    return SubmitAsync(&TaxSettingsClient::DeleteTaxRegistration, request, handler, context);
  }
 
  virtual Model::GetTaxExemptionTypesOutcome GetTaxExemptionTypes(const Model::GetTaxExemptionTypesRequest& request = {}) const;
 
  template <typename GetTaxExemptionTypesRequestT = Model::GetTaxExemptionTypesRequest>
  Model::GetTaxExemptionTypesOutcomeCallable GetTaxExemptionTypesCallable(const GetTaxExemptionTypesRequestT& request = {}) const {
    return SubmitCallable(&TaxSettingsClient::GetTaxExemptionTypes, request);
  }
 
  template <typename GetTaxExemptionTypesRequestT = Model::GetTaxExemptionTypesRequest>
  void GetTaxExemptionTypesAsync(const GetTaxExemptionTypesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const GetTaxExemptionTypesRequestT& request = {}) const {
    return SubmitAsync(&TaxSettingsClient::GetTaxExemptionTypes, request, handler, context);
  }
 
  virtual Model::GetTaxInheritanceOutcome GetTaxInheritance(const Model::GetTaxInheritanceRequest& request = {}) const;
 
  template <typename GetTaxInheritanceRequestT = Model::GetTaxInheritanceRequest>
  Model::GetTaxInheritanceOutcomeCallable GetTaxInheritanceCallable(const GetTaxInheritanceRequestT& request = {}) const {
    return SubmitCallable(&TaxSettingsClient::GetTaxInheritance, request);
  }
 
  template <typename GetTaxInheritanceRequestT = Model::GetTaxInheritanceRequest>
  void GetTaxInheritanceAsync(const GetTaxInheritanceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const GetTaxInheritanceRequestT& request = {}) const {
    return SubmitAsync(&TaxSettingsClient::GetTaxInheritance, request, handler, context);
  }
 
  virtual Model::GetTaxRegistrationOutcome GetTaxRegistration(const Model::GetTaxRegistrationRequest& request = {}) const;
 
  template <typename GetTaxRegistrationRequestT = Model::GetTaxRegistrationRequest>
  Model::GetTaxRegistrationOutcomeCallable GetTaxRegistrationCallable(const GetTaxRegistrationRequestT& request = {}) const {
    return SubmitCallable(&TaxSettingsClient::GetTaxRegistration, request);
  }
 
  template <typename GetTaxRegistrationRequestT = Model::GetTaxRegistrationRequest>
  void GetTaxRegistrationAsync(const GetTaxRegistrationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetTaxRegistrationRequestT& request = {}) const {
    return SubmitAsync(&TaxSettingsClient::GetTaxRegistration, request, handler, context);
  }
 
  virtual Model::GetTaxRegistrationDocumentOutcome GetTaxRegistrationDocument(
      const Model::GetTaxRegistrationDocumentRequest& request) const;
 
  template <typename GetTaxRegistrationDocumentRequestT = Model::GetTaxRegistrationDocumentRequest>
  Model::GetTaxRegistrationDocumentOutcomeCallable GetTaxRegistrationDocumentCallable(
      const GetTaxRegistrationDocumentRequestT& request) const {
    return SubmitCallable(&TaxSettingsClient::GetTaxRegistrationDocument, request);
  }
 
  template <typename GetTaxRegistrationDocumentRequestT = Model::GetTaxRegistrationDocumentRequest>
  void GetTaxRegistrationDocumentAsync(const GetTaxRegistrationDocumentRequestT& request,
                                       const GetTaxRegistrationDocumentResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TaxSettingsClient::GetTaxRegistrationDocument, request, handler, context);
  }
 
  virtual Model::ListSupplementalTaxRegistrationsOutcome ListSupplementalTaxRegistrations(
      const Model::ListSupplementalTaxRegistrationsRequest& request = {}) const;
 
  template <typename ListSupplementalTaxRegistrationsRequestT = Model::ListSupplementalTaxRegistrationsRequest>
  Model::ListSupplementalTaxRegistrationsOutcomeCallable ListSupplementalTaxRegistrationsCallable(
      const ListSupplementalTaxRegistrationsRequestT& request = {}) const {
    return SubmitCallable(&TaxSettingsClient::ListSupplementalTaxRegistrations, request);
  }
 
  template <typename ListSupplementalTaxRegistrationsRequestT = Model::ListSupplementalTaxRegistrationsRequest>
  void ListSupplementalTaxRegistrationsAsync(const ListSupplementalTaxRegistrationsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const ListSupplementalTaxRegistrationsRequestT& request = {}) const {
    return SubmitAsync(&TaxSettingsClient::ListSupplementalTaxRegistrations, request, handler, context);
  }
 
  virtual Model::ListTaxExemptionsOutcome ListTaxExemptions(const Model::ListTaxExemptionsRequest& request = {}) const;
 
  template <typename ListTaxExemptionsRequestT = Model::ListTaxExemptionsRequest>
  Model::ListTaxExemptionsOutcomeCallable ListTaxExemptionsCallable(const ListTaxExemptionsRequestT& request = {}) const {
    return SubmitCallable(&TaxSettingsClient::ListTaxExemptions, request);
  }
 
  template <typename ListTaxExemptionsRequestT = Model::ListTaxExemptionsRequest>
  void ListTaxExemptionsAsync(const ListTaxExemptionsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListTaxExemptionsRequestT& request = {}) const {
    return SubmitAsync(&TaxSettingsClient::ListTaxExemptions, request, handler, context);
  }
 
  virtual Model::ListTaxRegistrationsOutcome ListTaxRegistrations(const Model::ListTaxRegistrationsRequest& request = {}) const;
 
  template <typename ListTaxRegistrationsRequestT = Model::ListTaxRegistrationsRequest>
  Model::ListTaxRegistrationsOutcomeCallable ListTaxRegistrationsCallable(const ListTaxRegistrationsRequestT& request = {}) const {
    return SubmitCallable(&TaxSettingsClient::ListTaxRegistrations, request);
  }
 
  template <typename ListTaxRegistrationsRequestT = Model::ListTaxRegistrationsRequest>
  void ListTaxRegistrationsAsync(const ListTaxRegistrationsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListTaxRegistrationsRequestT& request = {}) const {
    return SubmitAsync(&TaxSettingsClient::ListTaxRegistrations, request, handler, context);
  }
 
  virtual Model::PutSupplementalTaxRegistrationOutcome PutSupplementalTaxRegistration(
      const Model::PutSupplementalTaxRegistrationRequest& request) const;
 
  template <typename PutSupplementalTaxRegistrationRequestT = Model::PutSupplementalTaxRegistrationRequest>
  Model::PutSupplementalTaxRegistrationOutcomeCallable PutSupplementalTaxRegistrationCallable(
      const PutSupplementalTaxRegistrationRequestT& request) const {
    return SubmitCallable(&TaxSettingsClient::PutSupplementalTaxRegistration, request);
  }
 
  template <typename PutSupplementalTaxRegistrationRequestT = Model::PutSupplementalTaxRegistrationRequest>
  void PutSupplementalTaxRegistrationAsync(const PutSupplementalTaxRegistrationRequestT& request,
                                           const PutSupplementalTaxRegistrationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TaxSettingsClient::PutSupplementalTaxRegistration, request, handler, context);
  }
 
  virtual Model::PutTaxExemptionOutcome PutTaxExemption(const Model::PutTaxExemptionRequest& request) const;
 
  template <typename PutTaxExemptionRequestT = Model::PutTaxExemptionRequest>
  Model::PutTaxExemptionOutcomeCallable PutTaxExemptionCallable(const PutTaxExemptionRequestT& request) const {
    return SubmitCallable(&TaxSettingsClient::PutTaxExemption, request);
  }
 
  template <typename PutTaxExemptionRequestT = Model::PutTaxExemptionRequest>
  void PutTaxExemptionAsync(const PutTaxExemptionRequestT& request, const PutTaxExemptionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TaxSettingsClient::PutTaxExemption, request, handler, context);
  }
 
  virtual Model::PutTaxInheritanceOutcome PutTaxInheritance(const Model::PutTaxInheritanceRequest& request = {}) const;
 
  template <typename PutTaxInheritanceRequestT = Model::PutTaxInheritanceRequest>
  Model::PutTaxInheritanceOutcomeCallable PutTaxInheritanceCallable(const PutTaxInheritanceRequestT& request = {}) const {
    return SubmitCallable(&TaxSettingsClient::PutTaxInheritance, request);
  }
 
  template <typename PutTaxInheritanceRequestT = Model::PutTaxInheritanceRequest>
  void PutTaxInheritanceAsync(const PutTaxInheritanceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const PutTaxInheritanceRequestT& request = {}) const {
    return SubmitAsync(&TaxSettingsClient::PutTaxInheritance, request, handler, context);
  }
 
  virtual Model::PutTaxRegistrationOutcome PutTaxRegistration(const Model::PutTaxRegistrationRequest& request) const;
 
  template <typename PutTaxRegistrationRequestT = Model::PutTaxRegistrationRequest>
  Model::PutTaxRegistrationOutcomeCallable PutTaxRegistrationCallable(const PutTaxRegistrationRequestT& request) const {
    return SubmitCallable(&TaxSettingsClient::PutTaxRegistration, request);
  }
 
  template <typename PutTaxRegistrationRequestT = Model::PutTaxRegistrationRequest>
  void PutTaxRegistrationAsync(const PutTaxRegistrationRequestT& request, const PutTaxRegistrationResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TaxSettingsClient::PutTaxRegistration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<TaxSettingsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<TaxSettingsClient>;
  void init(const TaxSettingsClientConfiguration& clientConfiguration);
 
  TaxSettingsClientConfiguration m_clientConfiguration;
  std::shared_ptr<TaxSettingsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace TaxSettings
}  // namespace Aws