PartnerCentralBenefitsClient.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/partnercentral-benefits/PartnerCentralBenefitsPaginationBase.h>
#include <aws/partnercentral-benefits/PartnerCentralBenefitsServiceClientModel.h>
#include <aws/partnercentral-benefits/PartnerCentralBenefitsWaiter.h>
#include <aws/partnercentral-benefits/PartnerCentralBenefits_EXPORTS.h>
 
namespace Aws {
namespace PartnerCentralBenefits {
class AWS_PARTNERCENTRALBENEFITS_API PartnerCentralBenefitsClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<PartnerCentralBenefitsClient>,
      public PartnerCentralBenefitsPaginationBase<PartnerCentralBenefitsClient>,
      public PartnerCentralBenefitsWaiter<PartnerCentralBenefitsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef PartnerCentralBenefitsClientConfiguration ClientConfigurationType;
  typedef PartnerCentralBenefitsEndpointProvider EndpointProviderType;
 
  PartnerCentralBenefitsClient(const Aws::PartnerCentralBenefits::PartnerCentralBenefitsClientConfiguration& clientConfiguration =
                                   Aws::PartnerCentralBenefits::PartnerCentralBenefitsClientConfiguration(),
                               std::shared_ptr<PartnerCentralBenefitsEndpointProviderBase> endpointProvider = nullptr);
 
  PartnerCentralBenefitsClient(const Aws::Auth::AWSCredentials& credentials,
                               std::shared_ptr<PartnerCentralBenefitsEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::PartnerCentralBenefits::PartnerCentralBenefitsClientConfiguration& clientConfiguration =
                                   Aws::PartnerCentralBenefits::PartnerCentralBenefitsClientConfiguration());
 
  PartnerCentralBenefitsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               std::shared_ptr<PartnerCentralBenefitsEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::PartnerCentralBenefits::PartnerCentralBenefitsClientConfiguration& clientConfiguration =
                                   Aws::PartnerCentralBenefits::PartnerCentralBenefitsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  PartnerCentralBenefitsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PartnerCentralBenefitsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PartnerCentralBenefitsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~PartnerCentralBenefitsClient();
 
  virtual Model::AmendBenefitApplicationOutcome AmendBenefitApplication(const Model::AmendBenefitApplicationRequest& request) const;
 
  template <typename AmendBenefitApplicationRequestT = Model::AmendBenefitApplicationRequest>
  Model::AmendBenefitApplicationOutcomeCallable AmendBenefitApplicationCallable(const AmendBenefitApplicationRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::AmendBenefitApplication, request);
  }
 
  template <typename AmendBenefitApplicationRequestT = Model::AmendBenefitApplicationRequest>
  void AmendBenefitApplicationAsync(const AmendBenefitApplicationRequestT& request,
                                    const AmendBenefitApplicationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::AmendBenefitApplication, request, handler, context);
  }
 
  virtual Model::AssociateBenefitApplicationResourceOutcome AssociateBenefitApplicationResource(
      const Model::AssociateBenefitApplicationResourceRequest& request) const;
 
  template <typename AssociateBenefitApplicationResourceRequestT = Model::AssociateBenefitApplicationResourceRequest>
  Model::AssociateBenefitApplicationResourceOutcomeCallable AssociateBenefitApplicationResourceCallable(
      const AssociateBenefitApplicationResourceRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::AssociateBenefitApplicationResource, request);
  }
 
  template <typename AssociateBenefitApplicationResourceRequestT = Model::AssociateBenefitApplicationResourceRequest>
  void AssociateBenefitApplicationResourceAsync(const AssociateBenefitApplicationResourceRequestT& request,
                                                const AssociateBenefitApplicationResourceResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::AssociateBenefitApplicationResource, request, handler, context);
  }
 
  virtual Model::CancelBenefitApplicationOutcome CancelBenefitApplication(const Model::CancelBenefitApplicationRequest& request) const;
 
  template <typename CancelBenefitApplicationRequestT = Model::CancelBenefitApplicationRequest>
  Model::CancelBenefitApplicationOutcomeCallable CancelBenefitApplicationCallable(const CancelBenefitApplicationRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::CancelBenefitApplication, request);
  }
 
  template <typename CancelBenefitApplicationRequestT = Model::CancelBenefitApplicationRequest>
  void CancelBenefitApplicationAsync(const CancelBenefitApplicationRequestT& request,
                                     const CancelBenefitApplicationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::CancelBenefitApplication, request, handler, context);
  }
 
  virtual Model::CreateBenefitApplicationOutcome CreateBenefitApplication(const Model::CreateBenefitApplicationRequest& request) const;
 
  template <typename CreateBenefitApplicationRequestT = Model::CreateBenefitApplicationRequest>
  Model::CreateBenefitApplicationOutcomeCallable CreateBenefitApplicationCallable(const CreateBenefitApplicationRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::CreateBenefitApplication, request);
  }
 
  template <typename CreateBenefitApplicationRequestT = Model::CreateBenefitApplicationRequest>
  void CreateBenefitApplicationAsync(const CreateBenefitApplicationRequestT& request,
                                     const CreateBenefitApplicationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::CreateBenefitApplication, request, handler, context);
  }
 
  virtual Model::DisassociateBenefitApplicationResourceOutcome DisassociateBenefitApplicationResource(
      const Model::DisassociateBenefitApplicationResourceRequest& request) const;
 
  template <typename DisassociateBenefitApplicationResourceRequestT = Model::DisassociateBenefitApplicationResourceRequest>
  Model::DisassociateBenefitApplicationResourceOutcomeCallable DisassociateBenefitApplicationResourceCallable(
      const DisassociateBenefitApplicationResourceRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::DisassociateBenefitApplicationResource, request);
  }
 
  template <typename DisassociateBenefitApplicationResourceRequestT = Model::DisassociateBenefitApplicationResourceRequest>
  void DisassociateBenefitApplicationResourceAsync(const DisassociateBenefitApplicationResourceRequestT& request,
                                                   const DisassociateBenefitApplicationResourceResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::DisassociateBenefitApplicationResource, request, handler, context);
  }
 
  virtual Model::GetBenefitOutcome GetBenefit(const Model::GetBenefitRequest& request) const;
 
  template <typename GetBenefitRequestT = Model::GetBenefitRequest>
  Model::GetBenefitOutcomeCallable GetBenefitCallable(const GetBenefitRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::GetBenefit, request);
  }
 
  template <typename GetBenefitRequestT = Model::GetBenefitRequest>
  void GetBenefitAsync(const GetBenefitRequestT& request, const GetBenefitResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::GetBenefit, request, handler, context);
  }
 
  virtual Model::GetBenefitAllocationOutcome GetBenefitAllocation(const Model::GetBenefitAllocationRequest& request) const;
 
  template <typename GetBenefitAllocationRequestT = Model::GetBenefitAllocationRequest>
  Model::GetBenefitAllocationOutcomeCallable GetBenefitAllocationCallable(const GetBenefitAllocationRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::GetBenefitAllocation, request);
  }
 
  template <typename GetBenefitAllocationRequestT = Model::GetBenefitAllocationRequest>
  void GetBenefitAllocationAsync(const GetBenefitAllocationRequestT& request, const GetBenefitAllocationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::GetBenefitAllocation, request, handler, context);
  }
 
  virtual Model::GetBenefitApplicationOutcome GetBenefitApplication(const Model::GetBenefitApplicationRequest& request) const;
 
  template <typename GetBenefitApplicationRequestT = Model::GetBenefitApplicationRequest>
  Model::GetBenefitApplicationOutcomeCallable GetBenefitApplicationCallable(const GetBenefitApplicationRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::GetBenefitApplication, request);
  }
 
  template <typename GetBenefitApplicationRequestT = Model::GetBenefitApplicationRequest>
  void GetBenefitApplicationAsync(const GetBenefitApplicationRequestT& request, const GetBenefitApplicationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::GetBenefitApplication, request, handler, context);
  }
 
  virtual Model::ListBenefitAllocationsOutcome ListBenefitAllocations(const Model::ListBenefitAllocationsRequest& request) const;
 
  template <typename ListBenefitAllocationsRequestT = Model::ListBenefitAllocationsRequest>
  Model::ListBenefitAllocationsOutcomeCallable ListBenefitAllocationsCallable(const ListBenefitAllocationsRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::ListBenefitAllocations, request);
  }
 
  template <typename ListBenefitAllocationsRequestT = Model::ListBenefitAllocationsRequest>
  void ListBenefitAllocationsAsync(const ListBenefitAllocationsRequestT& request,
                                   const ListBenefitAllocationsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::ListBenefitAllocations, request, handler, context);
  }
 
  virtual Model::ListBenefitApplicationsOutcome ListBenefitApplications(const Model::ListBenefitApplicationsRequest& request) const;
 
  template <typename ListBenefitApplicationsRequestT = Model::ListBenefitApplicationsRequest>
  Model::ListBenefitApplicationsOutcomeCallable ListBenefitApplicationsCallable(const ListBenefitApplicationsRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::ListBenefitApplications, request);
  }
 
  template <typename ListBenefitApplicationsRequestT = Model::ListBenefitApplicationsRequest>
  void ListBenefitApplicationsAsync(const ListBenefitApplicationsRequestT& request,
                                    const ListBenefitApplicationsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::ListBenefitApplications, request, handler, context);
  }
 
  virtual Model::ListBenefitsOutcome ListBenefits(const Model::ListBenefitsRequest& request) const;
 
  template <typename ListBenefitsRequestT = Model::ListBenefitsRequest>
  Model::ListBenefitsOutcomeCallable ListBenefitsCallable(const ListBenefitsRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::ListBenefits, request);
  }
 
  template <typename ListBenefitsRequestT = Model::ListBenefitsRequest>
  void ListBenefitsAsync(const ListBenefitsRequestT& request, const ListBenefitsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::ListBenefits, 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(&PartnerCentralBenefitsClient::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(&PartnerCentralBenefitsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RecallBenefitApplicationOutcome RecallBenefitApplication(const Model::RecallBenefitApplicationRequest& request) const;
 
  template <typename RecallBenefitApplicationRequestT = Model::RecallBenefitApplicationRequest>
  Model::RecallBenefitApplicationOutcomeCallable RecallBenefitApplicationCallable(const RecallBenefitApplicationRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::RecallBenefitApplication, request);
  }
 
  template <typename RecallBenefitApplicationRequestT = Model::RecallBenefitApplicationRequest>
  void RecallBenefitApplicationAsync(const RecallBenefitApplicationRequestT& request,
                                     const RecallBenefitApplicationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::RecallBenefitApplication, request, handler, context);
  }
 
  virtual Model::SubmitBenefitApplicationOutcome SubmitBenefitApplication(const Model::SubmitBenefitApplicationRequest& request) const;
 
  template <typename SubmitBenefitApplicationRequestT = Model::SubmitBenefitApplicationRequest>
  Model::SubmitBenefitApplicationOutcomeCallable SubmitBenefitApplicationCallable(const SubmitBenefitApplicationRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::SubmitBenefitApplication, request);
  }
 
  template <typename SubmitBenefitApplicationRequestT = Model::SubmitBenefitApplicationRequest>
  void SubmitBenefitApplicationAsync(const SubmitBenefitApplicationRequestT& request,
                                     const SubmitBenefitApplicationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::SubmitBenefitApplication, 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(&PartnerCentralBenefitsClient::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(&PartnerCentralBenefitsClient::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(&PartnerCentralBenefitsClient::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(&PartnerCentralBenefitsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateBenefitApplicationOutcome UpdateBenefitApplication(const Model::UpdateBenefitApplicationRequest& request) const;
 
  template <typename UpdateBenefitApplicationRequestT = Model::UpdateBenefitApplicationRequest>
  Model::UpdateBenefitApplicationOutcomeCallable UpdateBenefitApplicationCallable(const UpdateBenefitApplicationRequestT& request) const {
    return SubmitCallable(&PartnerCentralBenefitsClient::UpdateBenefitApplication, request);
  }
 
  template <typename UpdateBenefitApplicationRequestT = Model::UpdateBenefitApplicationRequest>
  void UpdateBenefitApplicationAsync(const UpdateBenefitApplicationRequestT& request,
                                     const UpdateBenefitApplicationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralBenefitsClient::UpdateBenefitApplication, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PartnerCentralBenefitsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PartnerCentralBenefitsClient>;
  void init(const PartnerCentralBenefitsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, PartnerCentralBenefitsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  PartnerCentralBenefitsClientConfiguration m_clientConfiguration;
  std::shared_ptr<PartnerCentralBenefitsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace PartnerCentralBenefits
}  // namespace Aws