PartnerCentralAccountClient.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-account/PartnerCentralAccountPaginationBase.h>
#include <aws/partnercentral-account/PartnerCentralAccountServiceClientModel.h>
#include <aws/partnercentral-account/PartnerCentralAccount_EXPORTS.h>
 
namespace Aws {
namespace PartnerCentralAccount {
class AWS_PARTNERCENTRALACCOUNT_API PartnerCentralAccountClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<PartnerCentralAccountClient>,
      public PartnerCentralAccountPaginationBase<PartnerCentralAccountClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef PartnerCentralAccountClientConfiguration ClientConfigurationType;
  typedef PartnerCentralAccountEndpointProvider EndpointProviderType;
 
  PartnerCentralAccountClient(const Aws::PartnerCentralAccount::PartnerCentralAccountClientConfiguration& clientConfiguration =
                                  Aws::PartnerCentralAccount::PartnerCentralAccountClientConfiguration(),
                              std::shared_ptr<PartnerCentralAccountEndpointProviderBase> endpointProvider = nullptr);
 
  PartnerCentralAccountClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<PartnerCentralAccountEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::PartnerCentralAccount::PartnerCentralAccountClientConfiguration& clientConfiguration =
                                  Aws::PartnerCentralAccount::PartnerCentralAccountClientConfiguration());
 
  PartnerCentralAccountClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<PartnerCentralAccountEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::PartnerCentralAccount::PartnerCentralAccountClientConfiguration& clientConfiguration =
                                  Aws::PartnerCentralAccount::PartnerCentralAccountClientConfiguration());
 
  /* Legacy constructors due deprecation */
  PartnerCentralAccountClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PartnerCentralAccountClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PartnerCentralAccountClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~PartnerCentralAccountClient();
 
  virtual Model::AcceptConnectionInvitationOutcome AcceptConnectionInvitation(
      const Model::AcceptConnectionInvitationRequest& request) const;
 
  template <typename AcceptConnectionInvitationRequestT = Model::AcceptConnectionInvitationRequest>
  Model::AcceptConnectionInvitationOutcomeCallable AcceptConnectionInvitationCallable(
      const AcceptConnectionInvitationRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::AcceptConnectionInvitation, request);
  }
 
  template <typename AcceptConnectionInvitationRequestT = Model::AcceptConnectionInvitationRequest>
  void AcceptConnectionInvitationAsync(const AcceptConnectionInvitationRequestT& request,
                                       const AcceptConnectionInvitationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::AcceptConnectionInvitation, request, handler, context);
  }
 
  virtual Model::AssociateAwsTrainingCertificationEmailDomainOutcome AssociateAwsTrainingCertificationEmailDomain(
      const Model::AssociateAwsTrainingCertificationEmailDomainRequest& request) const;
 
  template <typename AssociateAwsTrainingCertificationEmailDomainRequestT = Model::AssociateAwsTrainingCertificationEmailDomainRequest>
  Model::AssociateAwsTrainingCertificationEmailDomainOutcomeCallable AssociateAwsTrainingCertificationEmailDomainCallable(
      const AssociateAwsTrainingCertificationEmailDomainRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::AssociateAwsTrainingCertificationEmailDomain, request);
  }
 
  template <typename AssociateAwsTrainingCertificationEmailDomainRequestT = Model::AssociateAwsTrainingCertificationEmailDomainRequest>
  void AssociateAwsTrainingCertificationEmailDomainAsync(
      const AssociateAwsTrainingCertificationEmailDomainRequestT& request,
      const AssociateAwsTrainingCertificationEmailDomainResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::AssociateAwsTrainingCertificationEmailDomain, request, handler, context);
  }
 
  virtual Model::CancelConnectionOutcome CancelConnection(const Model::CancelConnectionRequest& request) const;
 
  template <typename CancelConnectionRequestT = Model::CancelConnectionRequest>
  Model::CancelConnectionOutcomeCallable CancelConnectionCallable(const CancelConnectionRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::CancelConnection, request);
  }
 
  template <typename CancelConnectionRequestT = Model::CancelConnectionRequest>
  void CancelConnectionAsync(const CancelConnectionRequestT& request, const CancelConnectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::CancelConnection, request, handler, context);
  }
 
  virtual Model::CancelConnectionInvitationOutcome CancelConnectionInvitation(
      const Model::CancelConnectionInvitationRequest& request) const;
 
  template <typename CancelConnectionInvitationRequestT = Model::CancelConnectionInvitationRequest>
  Model::CancelConnectionInvitationOutcomeCallable CancelConnectionInvitationCallable(
      const CancelConnectionInvitationRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::CancelConnectionInvitation, request);
  }
 
  template <typename CancelConnectionInvitationRequestT = Model::CancelConnectionInvitationRequest>
  void CancelConnectionInvitationAsync(const CancelConnectionInvitationRequestT& request,
                                       const CancelConnectionInvitationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::CancelConnectionInvitation, request, handler, context);
  }
 
  virtual Model::CancelProfileUpdateTaskOutcome CancelProfileUpdateTask(const Model::CancelProfileUpdateTaskRequest& request) const;
 
  template <typename CancelProfileUpdateTaskRequestT = Model::CancelProfileUpdateTaskRequest>
  Model::CancelProfileUpdateTaskOutcomeCallable CancelProfileUpdateTaskCallable(const CancelProfileUpdateTaskRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::CancelProfileUpdateTask, request);
  }
 
  template <typename CancelProfileUpdateTaskRequestT = Model::CancelProfileUpdateTaskRequest>
  void CancelProfileUpdateTaskAsync(const CancelProfileUpdateTaskRequestT& request,
                                    const CancelProfileUpdateTaskResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::CancelProfileUpdateTask, request, handler, context);
  }
 
  virtual Model::CreateConnectionInvitationOutcome CreateConnectionInvitation(
      const Model::CreateConnectionInvitationRequest& request) const;
 
  template <typename CreateConnectionInvitationRequestT = Model::CreateConnectionInvitationRequest>
  Model::CreateConnectionInvitationOutcomeCallable CreateConnectionInvitationCallable(
      const CreateConnectionInvitationRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::CreateConnectionInvitation, request);
  }
 
  template <typename CreateConnectionInvitationRequestT = Model::CreateConnectionInvitationRequest>
  void CreateConnectionInvitationAsync(const CreateConnectionInvitationRequestT& request,
                                       const CreateConnectionInvitationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::CreateConnectionInvitation, request, handler, context);
  }
 
  virtual Model::CreatePartnerOutcome CreatePartner(const Model::CreatePartnerRequest& request) const;
 
  template <typename CreatePartnerRequestT = Model::CreatePartnerRequest>
  Model::CreatePartnerOutcomeCallable CreatePartnerCallable(const CreatePartnerRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::CreatePartner, request);
  }
 
  template <typename CreatePartnerRequestT = Model::CreatePartnerRequest>
  void CreatePartnerAsync(const CreatePartnerRequestT& request, const CreatePartnerResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::CreatePartner, request, handler, context);
  }
 
  virtual Model::DisassociateAwsTrainingCertificationEmailDomainOutcome DisassociateAwsTrainingCertificationEmailDomain(
      const Model::DisassociateAwsTrainingCertificationEmailDomainRequest& request) const;
 
  template <
      typename DisassociateAwsTrainingCertificationEmailDomainRequestT = Model::DisassociateAwsTrainingCertificationEmailDomainRequest>
  Model::DisassociateAwsTrainingCertificationEmailDomainOutcomeCallable DisassociateAwsTrainingCertificationEmailDomainCallable(
      const DisassociateAwsTrainingCertificationEmailDomainRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::DisassociateAwsTrainingCertificationEmailDomain, request);
  }
 
  template <
      typename DisassociateAwsTrainingCertificationEmailDomainRequestT = Model::DisassociateAwsTrainingCertificationEmailDomainRequest>
  void DisassociateAwsTrainingCertificationEmailDomainAsync(
      const DisassociateAwsTrainingCertificationEmailDomainRequestT& request,
      const DisassociateAwsTrainingCertificationEmailDomainResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::DisassociateAwsTrainingCertificationEmailDomain, request, handler, context);
  }
 
  virtual Model::GetAllianceLeadContactOutcome GetAllianceLeadContact(const Model::GetAllianceLeadContactRequest& request) const;
 
  template <typename GetAllianceLeadContactRequestT = Model::GetAllianceLeadContactRequest>
  Model::GetAllianceLeadContactOutcomeCallable GetAllianceLeadContactCallable(const GetAllianceLeadContactRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::GetAllianceLeadContact, request);
  }
 
  template <typename GetAllianceLeadContactRequestT = Model::GetAllianceLeadContactRequest>
  void GetAllianceLeadContactAsync(const GetAllianceLeadContactRequestT& request,
                                   const GetAllianceLeadContactResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::GetAllianceLeadContact, request, handler, context);
  }
 
  virtual Model::GetConnectionOutcome GetConnection(const Model::GetConnectionRequest& request) const;
 
  template <typename GetConnectionRequestT = Model::GetConnectionRequest>
  Model::GetConnectionOutcomeCallable GetConnectionCallable(const GetConnectionRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::GetConnection, request);
  }
 
  template <typename GetConnectionRequestT = Model::GetConnectionRequest>
  void GetConnectionAsync(const GetConnectionRequestT& request, const GetConnectionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::GetConnection, request, handler, context);
  }
 
  virtual Model::GetConnectionInvitationOutcome GetConnectionInvitation(const Model::GetConnectionInvitationRequest& request) const;
 
  template <typename GetConnectionInvitationRequestT = Model::GetConnectionInvitationRequest>
  Model::GetConnectionInvitationOutcomeCallable GetConnectionInvitationCallable(const GetConnectionInvitationRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::GetConnectionInvitation, request);
  }
 
  template <typename GetConnectionInvitationRequestT = Model::GetConnectionInvitationRequest>
  void GetConnectionInvitationAsync(const GetConnectionInvitationRequestT& request,
                                    const GetConnectionInvitationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::GetConnectionInvitation, request, handler, context);
  }
 
  virtual Model::GetConnectionPreferencesOutcome GetConnectionPreferences(const Model::GetConnectionPreferencesRequest& request) const;
 
  template <typename GetConnectionPreferencesRequestT = Model::GetConnectionPreferencesRequest>
  Model::GetConnectionPreferencesOutcomeCallable GetConnectionPreferencesCallable(const GetConnectionPreferencesRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::GetConnectionPreferences, request);
  }
 
  template <typename GetConnectionPreferencesRequestT = Model::GetConnectionPreferencesRequest>
  void GetConnectionPreferencesAsync(const GetConnectionPreferencesRequestT& request,
                                     const GetConnectionPreferencesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::GetConnectionPreferences, request, handler, context);
  }
 
  virtual Model::GetPartnerOutcome GetPartner(const Model::GetPartnerRequest& request) const;
 
  template <typename GetPartnerRequestT = Model::GetPartnerRequest>
  Model::GetPartnerOutcomeCallable GetPartnerCallable(const GetPartnerRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::GetPartner, request);
  }
 
  template <typename GetPartnerRequestT = Model::GetPartnerRequest>
  void GetPartnerAsync(const GetPartnerRequestT& request, const GetPartnerResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::GetPartner, request, handler, context);
  }
 
  virtual Model::GetProfileUpdateTaskOutcome GetProfileUpdateTask(const Model::GetProfileUpdateTaskRequest& request) const;
 
  template <typename GetProfileUpdateTaskRequestT = Model::GetProfileUpdateTaskRequest>
  Model::GetProfileUpdateTaskOutcomeCallable GetProfileUpdateTaskCallable(const GetProfileUpdateTaskRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::GetProfileUpdateTask, request);
  }
 
  template <typename GetProfileUpdateTaskRequestT = Model::GetProfileUpdateTaskRequest>
  void GetProfileUpdateTaskAsync(const GetProfileUpdateTaskRequestT& request, const GetProfileUpdateTaskResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::GetProfileUpdateTask, request, handler, context);
  }
 
  virtual Model::GetProfileVisibilityOutcome GetProfileVisibility(const Model::GetProfileVisibilityRequest& request) const;
 
  template <typename GetProfileVisibilityRequestT = Model::GetProfileVisibilityRequest>
  Model::GetProfileVisibilityOutcomeCallable GetProfileVisibilityCallable(const GetProfileVisibilityRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::GetProfileVisibility, request);
  }
 
  template <typename GetProfileVisibilityRequestT = Model::GetProfileVisibilityRequest>
  void GetProfileVisibilityAsync(const GetProfileVisibilityRequestT& request, const GetProfileVisibilityResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::GetProfileVisibility, request, handler, context);
  }
 
  virtual Model::GetVerificationOutcome GetVerification(const Model::GetVerificationRequest& request) const;
 
  template <typename GetVerificationRequestT = Model::GetVerificationRequest>
  Model::GetVerificationOutcomeCallable GetVerificationCallable(const GetVerificationRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::GetVerification, request);
  }
 
  template <typename GetVerificationRequestT = Model::GetVerificationRequest>
  void GetVerificationAsync(const GetVerificationRequestT& request, const GetVerificationResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::GetVerification, request, handler, context);
  }
 
  virtual Model::ListConnectionInvitationsOutcome ListConnectionInvitations(const Model::ListConnectionInvitationsRequest& request) const;
 
  template <typename ListConnectionInvitationsRequestT = Model::ListConnectionInvitationsRequest>
  Model::ListConnectionInvitationsOutcomeCallable ListConnectionInvitationsCallable(
      const ListConnectionInvitationsRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::ListConnectionInvitations, request);
  }
 
  template <typename ListConnectionInvitationsRequestT = Model::ListConnectionInvitationsRequest>
  void ListConnectionInvitationsAsync(const ListConnectionInvitationsRequestT& request,
                                      const ListConnectionInvitationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::ListConnectionInvitations, request, handler, context);
  }
 
  virtual Model::ListConnectionsOutcome ListConnections(const Model::ListConnectionsRequest& request) const;
 
  template <typename ListConnectionsRequestT = Model::ListConnectionsRequest>
  Model::ListConnectionsOutcomeCallable ListConnectionsCallable(const ListConnectionsRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::ListConnections, request);
  }
 
  template <typename ListConnectionsRequestT = Model::ListConnectionsRequest>
  void ListConnectionsAsync(const ListConnectionsRequestT& request, const ListConnectionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::ListConnections, request, handler, context);
  }
 
  virtual Model::ListPartnersOutcome ListPartners(const Model::ListPartnersRequest& request) const;
 
  template <typename ListPartnersRequestT = Model::ListPartnersRequest>
  Model::ListPartnersOutcomeCallable ListPartnersCallable(const ListPartnersRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::ListPartners, request);
  }
 
  template <typename ListPartnersRequestT = Model::ListPartnersRequest>
  void ListPartnersAsync(const ListPartnersRequestT& request, const ListPartnersResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::ListPartners, 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(&PartnerCentralAccountClient::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(&PartnerCentralAccountClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutAllianceLeadContactOutcome PutAllianceLeadContact(const Model::PutAllianceLeadContactRequest& request) const;
 
  template <typename PutAllianceLeadContactRequestT = Model::PutAllianceLeadContactRequest>
  Model::PutAllianceLeadContactOutcomeCallable PutAllianceLeadContactCallable(const PutAllianceLeadContactRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::PutAllianceLeadContact, request);
  }
 
  template <typename PutAllianceLeadContactRequestT = Model::PutAllianceLeadContactRequest>
  void PutAllianceLeadContactAsync(const PutAllianceLeadContactRequestT& request,
                                   const PutAllianceLeadContactResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::PutAllianceLeadContact, request, handler, context);
  }
 
  virtual Model::PutProfileVisibilityOutcome PutProfileVisibility(const Model::PutProfileVisibilityRequest& request) const;
 
  template <typename PutProfileVisibilityRequestT = Model::PutProfileVisibilityRequest>
  Model::PutProfileVisibilityOutcomeCallable PutProfileVisibilityCallable(const PutProfileVisibilityRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::PutProfileVisibility, request);
  }
 
  template <typename PutProfileVisibilityRequestT = Model::PutProfileVisibilityRequest>
  void PutProfileVisibilityAsync(const PutProfileVisibilityRequestT& request, const PutProfileVisibilityResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::PutProfileVisibility, request, handler, context);
  }
 
  virtual Model::RejectConnectionInvitationOutcome RejectConnectionInvitation(
      const Model::RejectConnectionInvitationRequest& request) const;
 
  template <typename RejectConnectionInvitationRequestT = Model::RejectConnectionInvitationRequest>
  Model::RejectConnectionInvitationOutcomeCallable RejectConnectionInvitationCallable(
      const RejectConnectionInvitationRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::RejectConnectionInvitation, request);
  }
 
  template <typename RejectConnectionInvitationRequestT = Model::RejectConnectionInvitationRequest>
  void RejectConnectionInvitationAsync(const RejectConnectionInvitationRequestT& request,
                                       const RejectConnectionInvitationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::RejectConnectionInvitation, request, handler, context);
  }
 
  virtual Model::SendEmailVerificationCodeOutcome SendEmailVerificationCode(const Model::SendEmailVerificationCodeRequest& request) const;
 
  template <typename SendEmailVerificationCodeRequestT = Model::SendEmailVerificationCodeRequest>
  Model::SendEmailVerificationCodeOutcomeCallable SendEmailVerificationCodeCallable(
      const SendEmailVerificationCodeRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::SendEmailVerificationCode, request);
  }
 
  template <typename SendEmailVerificationCodeRequestT = Model::SendEmailVerificationCodeRequest>
  void SendEmailVerificationCodeAsync(const SendEmailVerificationCodeRequestT& request,
                                      const SendEmailVerificationCodeResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::SendEmailVerificationCode, request, handler, context);
  }
 
  virtual Model::StartProfileUpdateTaskOutcome StartProfileUpdateTask(const Model::StartProfileUpdateTaskRequest& request) const;
 
  template <typename StartProfileUpdateTaskRequestT = Model::StartProfileUpdateTaskRequest>
  Model::StartProfileUpdateTaskOutcomeCallable StartProfileUpdateTaskCallable(const StartProfileUpdateTaskRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::StartProfileUpdateTask, request);
  }
 
  template <typename StartProfileUpdateTaskRequestT = Model::StartProfileUpdateTaskRequest>
  void StartProfileUpdateTaskAsync(const StartProfileUpdateTaskRequestT& request,
                                   const StartProfileUpdateTaskResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::StartProfileUpdateTask, request, handler, context);
  }
 
  virtual Model::StartVerificationOutcome StartVerification(const Model::StartVerificationRequest& request = {}) const;
 
  template <typename StartVerificationRequestT = Model::StartVerificationRequest>
  Model::StartVerificationOutcomeCallable StartVerificationCallable(const StartVerificationRequestT& request = {}) const {
    return SubmitCallable(&PartnerCentralAccountClient::StartVerification, request);
  }
 
  template <typename StartVerificationRequestT = Model::StartVerificationRequest>
  void StartVerificationAsync(const StartVerificationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const StartVerificationRequestT& request = {}) const {
    return SubmitAsync(&PartnerCentralAccountClient::StartVerification, 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(&PartnerCentralAccountClient::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(&PartnerCentralAccountClient::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(&PartnerCentralAccountClient::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(&PartnerCentralAccountClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateConnectionPreferencesOutcome UpdateConnectionPreferences(
      const Model::UpdateConnectionPreferencesRequest& request) const;
 
  template <typename UpdateConnectionPreferencesRequestT = Model::UpdateConnectionPreferencesRequest>
  Model::UpdateConnectionPreferencesOutcomeCallable UpdateConnectionPreferencesCallable(
      const UpdateConnectionPreferencesRequestT& request) const {
    return SubmitCallable(&PartnerCentralAccountClient::UpdateConnectionPreferences, request);
  }
 
  template <typename UpdateConnectionPreferencesRequestT = Model::UpdateConnectionPreferencesRequest>
  void UpdateConnectionPreferencesAsync(const UpdateConnectionPreferencesRequestT& request,
                                        const UpdateConnectionPreferencesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralAccountClient::UpdateConnectionPreferences, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PartnerCentralAccountEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PartnerCentralAccountClient>;
  void init(const PartnerCentralAccountClientConfiguration& clientConfiguration);
 
  PartnerCentralAccountClientConfiguration m_clientConfiguration;
  std::shared_ptr<PartnerCentralAccountEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace PartnerCentralAccount
}  // namespace Aws