PartnerCentralChannelClient.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-channel/PartnerCentralChannelPaginationBase.h>
#include <aws/partnercentral-channel/PartnerCentralChannelServiceClientModel.h>
#include <aws/partnercentral-channel/PartnerCentralChannel_EXPORTS.h>
 
namespace Aws {
namespace PartnerCentralChannel {
class AWS_PARTNERCENTRALCHANNEL_API PartnerCentralChannelClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<PartnerCentralChannelClient>,
      public PartnerCentralChannelPaginationBase<PartnerCentralChannelClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef PartnerCentralChannelClientConfiguration ClientConfigurationType;
  typedef PartnerCentralChannelEndpointProvider EndpointProviderType;
 
  PartnerCentralChannelClient(const Aws::PartnerCentralChannel::PartnerCentralChannelClientConfiguration& clientConfiguration =
                                  Aws::PartnerCentralChannel::PartnerCentralChannelClientConfiguration(),
                              std::shared_ptr<PartnerCentralChannelEndpointProviderBase> endpointProvider = nullptr);
 
  PartnerCentralChannelClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<PartnerCentralChannelEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::PartnerCentralChannel::PartnerCentralChannelClientConfiguration& clientConfiguration =
                                  Aws::PartnerCentralChannel::PartnerCentralChannelClientConfiguration());
 
  PartnerCentralChannelClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<PartnerCentralChannelEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::PartnerCentralChannel::PartnerCentralChannelClientConfiguration& clientConfiguration =
                                  Aws::PartnerCentralChannel::PartnerCentralChannelClientConfiguration());
 
  /* Legacy constructors due deprecation */
  PartnerCentralChannelClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PartnerCentralChannelClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PartnerCentralChannelClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~PartnerCentralChannelClient();
 
  virtual Model::AcceptChannelHandshakeOutcome AcceptChannelHandshake(const Model::AcceptChannelHandshakeRequest& request) const;
 
  template <typename AcceptChannelHandshakeRequestT = Model::AcceptChannelHandshakeRequest>
  Model::AcceptChannelHandshakeOutcomeCallable AcceptChannelHandshakeCallable(const AcceptChannelHandshakeRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::AcceptChannelHandshake, request);
  }
 
  template <typename AcceptChannelHandshakeRequestT = Model::AcceptChannelHandshakeRequest>
  void AcceptChannelHandshakeAsync(const AcceptChannelHandshakeRequestT& request,
                                   const AcceptChannelHandshakeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::AcceptChannelHandshake, request, handler, context);
  }
 
  virtual Model::CancelChannelHandshakeOutcome CancelChannelHandshake(const Model::CancelChannelHandshakeRequest& request) const;
 
  template <typename CancelChannelHandshakeRequestT = Model::CancelChannelHandshakeRequest>
  Model::CancelChannelHandshakeOutcomeCallable CancelChannelHandshakeCallable(const CancelChannelHandshakeRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::CancelChannelHandshake, request);
  }
 
  template <typename CancelChannelHandshakeRequestT = Model::CancelChannelHandshakeRequest>
  void CancelChannelHandshakeAsync(const CancelChannelHandshakeRequestT& request,
                                   const CancelChannelHandshakeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::CancelChannelHandshake, request, handler, context);
  }
 
  virtual Model::CreateChannelHandshakeOutcome CreateChannelHandshake(const Model::CreateChannelHandshakeRequest& request) const;
 
  template <typename CreateChannelHandshakeRequestT = Model::CreateChannelHandshakeRequest>
  Model::CreateChannelHandshakeOutcomeCallable CreateChannelHandshakeCallable(const CreateChannelHandshakeRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::CreateChannelHandshake, request);
  }
 
  template <typename CreateChannelHandshakeRequestT = Model::CreateChannelHandshakeRequest>
  void CreateChannelHandshakeAsync(const CreateChannelHandshakeRequestT& request,
                                   const CreateChannelHandshakeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::CreateChannelHandshake, request, handler, context);
  }
 
  virtual Model::CreateProgramManagementAccountOutcome CreateProgramManagementAccount(
      const Model::CreateProgramManagementAccountRequest& request) const;
 
  template <typename CreateProgramManagementAccountRequestT = Model::CreateProgramManagementAccountRequest>
  Model::CreateProgramManagementAccountOutcomeCallable CreateProgramManagementAccountCallable(
      const CreateProgramManagementAccountRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::CreateProgramManagementAccount, request);
  }
 
  template <typename CreateProgramManagementAccountRequestT = Model::CreateProgramManagementAccountRequest>
  void CreateProgramManagementAccountAsync(const CreateProgramManagementAccountRequestT& request,
                                           const CreateProgramManagementAccountResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::CreateProgramManagementAccount, request, handler, context);
  }
 
  virtual Model::CreateRelationshipOutcome CreateRelationship(const Model::CreateRelationshipRequest& request) const;
 
  template <typename CreateRelationshipRequestT = Model::CreateRelationshipRequest>
  Model::CreateRelationshipOutcomeCallable CreateRelationshipCallable(const CreateRelationshipRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::CreateRelationship, request);
  }
 
  template <typename CreateRelationshipRequestT = Model::CreateRelationshipRequest>
  void CreateRelationshipAsync(const CreateRelationshipRequestT& request, const CreateRelationshipResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::CreateRelationship, request, handler, context);
  }
 
  virtual Model::DeleteProgramManagementAccountOutcome DeleteProgramManagementAccount(
      const Model::DeleteProgramManagementAccountRequest& request) const;
 
  template <typename DeleteProgramManagementAccountRequestT = Model::DeleteProgramManagementAccountRequest>
  Model::DeleteProgramManagementAccountOutcomeCallable DeleteProgramManagementAccountCallable(
      const DeleteProgramManagementAccountRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::DeleteProgramManagementAccount, request);
  }
 
  template <typename DeleteProgramManagementAccountRequestT = Model::DeleteProgramManagementAccountRequest>
  void DeleteProgramManagementAccountAsync(const DeleteProgramManagementAccountRequestT& request,
                                           const DeleteProgramManagementAccountResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::DeleteProgramManagementAccount, request, handler, context);
  }
 
  virtual Model::DeleteRelationshipOutcome DeleteRelationship(const Model::DeleteRelationshipRequest& request) const;
 
  template <typename DeleteRelationshipRequestT = Model::DeleteRelationshipRequest>
  Model::DeleteRelationshipOutcomeCallable DeleteRelationshipCallable(const DeleteRelationshipRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::DeleteRelationship, request);
  }
 
  template <typename DeleteRelationshipRequestT = Model::DeleteRelationshipRequest>
  void DeleteRelationshipAsync(const DeleteRelationshipRequestT& request, const DeleteRelationshipResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::DeleteRelationship, request, handler, context);
  }
 
  virtual Model::GetRelationshipOutcome GetRelationship(const Model::GetRelationshipRequest& request) const;
 
  template <typename GetRelationshipRequestT = Model::GetRelationshipRequest>
  Model::GetRelationshipOutcomeCallable GetRelationshipCallable(const GetRelationshipRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::GetRelationship, request);
  }
 
  template <typename GetRelationshipRequestT = Model::GetRelationshipRequest>
  void GetRelationshipAsync(const GetRelationshipRequestT& request, const GetRelationshipResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::GetRelationship, request, handler, context);
  }
 
  virtual Model::ListChannelHandshakesOutcome ListChannelHandshakes(const Model::ListChannelHandshakesRequest& request) const;
 
  template <typename ListChannelHandshakesRequestT = Model::ListChannelHandshakesRequest>
  Model::ListChannelHandshakesOutcomeCallable ListChannelHandshakesCallable(const ListChannelHandshakesRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::ListChannelHandshakes, request);
  }
 
  template <typename ListChannelHandshakesRequestT = Model::ListChannelHandshakesRequest>
  void ListChannelHandshakesAsync(const ListChannelHandshakesRequestT& request, const ListChannelHandshakesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::ListChannelHandshakes, request, handler, context);
  }
 
  virtual Model::ListProgramManagementAccountsOutcome ListProgramManagementAccounts(
      const Model::ListProgramManagementAccountsRequest& request) const;
 
  template <typename ListProgramManagementAccountsRequestT = Model::ListProgramManagementAccountsRequest>
  Model::ListProgramManagementAccountsOutcomeCallable ListProgramManagementAccountsCallable(
      const ListProgramManagementAccountsRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::ListProgramManagementAccounts, request);
  }
 
  template <typename ListProgramManagementAccountsRequestT = Model::ListProgramManagementAccountsRequest>
  void ListProgramManagementAccountsAsync(const ListProgramManagementAccountsRequestT& request,
                                          const ListProgramManagementAccountsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::ListProgramManagementAccounts, request, handler, context);
  }
 
  virtual Model::ListRelationshipsOutcome ListRelationships(const Model::ListRelationshipsRequest& request) const;
 
  template <typename ListRelationshipsRequestT = Model::ListRelationshipsRequest>
  Model::ListRelationshipsOutcomeCallable ListRelationshipsCallable(const ListRelationshipsRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::ListRelationships, request);
  }
 
  template <typename ListRelationshipsRequestT = Model::ListRelationshipsRequest>
  void ListRelationshipsAsync(const ListRelationshipsRequestT& request, const ListRelationshipsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::ListRelationships, 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(&PartnerCentralChannelClient::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(&PartnerCentralChannelClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::RejectChannelHandshakeOutcome RejectChannelHandshake(const Model::RejectChannelHandshakeRequest& request) const;
 
  template <typename RejectChannelHandshakeRequestT = Model::RejectChannelHandshakeRequest>
  Model::RejectChannelHandshakeOutcomeCallable RejectChannelHandshakeCallable(const RejectChannelHandshakeRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::RejectChannelHandshake, request);
  }
 
  template <typename RejectChannelHandshakeRequestT = Model::RejectChannelHandshakeRequest>
  void RejectChannelHandshakeAsync(const RejectChannelHandshakeRequestT& request,
                                   const RejectChannelHandshakeResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::RejectChannelHandshake, 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(&PartnerCentralChannelClient::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(&PartnerCentralChannelClient::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(&PartnerCentralChannelClient::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(&PartnerCentralChannelClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateProgramManagementAccountOutcome UpdateProgramManagementAccount(
      const Model::UpdateProgramManagementAccountRequest& request) const;
 
  template <typename UpdateProgramManagementAccountRequestT = Model::UpdateProgramManagementAccountRequest>
  Model::UpdateProgramManagementAccountOutcomeCallable UpdateProgramManagementAccountCallable(
      const UpdateProgramManagementAccountRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::UpdateProgramManagementAccount, request);
  }
 
  template <typename UpdateProgramManagementAccountRequestT = Model::UpdateProgramManagementAccountRequest>
  void UpdateProgramManagementAccountAsync(const UpdateProgramManagementAccountRequestT& request,
                                           const UpdateProgramManagementAccountResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::UpdateProgramManagementAccount, request, handler, context);
  }
 
  virtual Model::UpdateRelationshipOutcome UpdateRelationship(const Model::UpdateRelationshipRequest& request) const;
 
  template <typename UpdateRelationshipRequestT = Model::UpdateRelationshipRequest>
  Model::UpdateRelationshipOutcomeCallable UpdateRelationshipCallable(const UpdateRelationshipRequestT& request) const {
    return SubmitCallable(&PartnerCentralChannelClient::UpdateRelationship, request);
  }
 
  template <typename UpdateRelationshipRequestT = Model::UpdateRelationshipRequest>
  void UpdateRelationshipAsync(const UpdateRelationshipRequestT& request, const UpdateRelationshipResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralChannelClient::UpdateRelationship, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PartnerCentralChannelEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PartnerCentralChannelClient>;
  void init(const PartnerCentralChannelClientConfiguration& clientConfiguration);
 
  PartnerCentralChannelClientConfiguration m_clientConfiguration;
  std::shared_ptr<PartnerCentralChannelEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace PartnerCentralChannel
}  // namespace Aws