PartnerCentralSellingClient.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-selling/PartnerCentralSellingPaginationBase.h>
#include <aws/partnercentral-selling/PartnerCentralSellingServiceClientModel.h>
#include <aws/partnercentral-selling/PartnerCentralSellingWaiter.h>
#include <aws/partnercentral-selling/PartnerCentralSelling_EXPORTS.h>
 
namespace Aws {
namespace PartnerCentralSelling {
class AWS_PARTNERCENTRALSELLING_API PartnerCentralSellingClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<PartnerCentralSellingClient>,
      public PartnerCentralSellingPaginationBase<PartnerCentralSellingClient>,
      public PartnerCentralSellingWaiter<PartnerCentralSellingClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef PartnerCentralSellingClientConfiguration ClientConfigurationType;
  typedef PartnerCentralSellingEndpointProvider EndpointProviderType;
 
  PartnerCentralSellingClient(const Aws::PartnerCentralSelling::PartnerCentralSellingClientConfiguration& clientConfiguration =
                                  Aws::PartnerCentralSelling::PartnerCentralSellingClientConfiguration(),
                              std::shared_ptr<PartnerCentralSellingEndpointProviderBase> endpointProvider = nullptr);
 
  PartnerCentralSellingClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<PartnerCentralSellingEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::PartnerCentralSelling::PartnerCentralSellingClientConfiguration& clientConfiguration =
                                  Aws::PartnerCentralSelling::PartnerCentralSellingClientConfiguration());
 
  PartnerCentralSellingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<PartnerCentralSellingEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::PartnerCentralSelling::PartnerCentralSellingClientConfiguration& clientConfiguration =
                                  Aws::PartnerCentralSelling::PartnerCentralSellingClientConfiguration());
 
  /* Legacy constructors due deprecation */
  PartnerCentralSellingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PartnerCentralSellingClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PartnerCentralSellingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~PartnerCentralSellingClient();
 
  virtual Model::AcceptEngagementInvitationOutcome AcceptEngagementInvitation(
      const Model::AcceptEngagementInvitationRequest& request) const;
 
  template <typename AcceptEngagementInvitationRequestT = Model::AcceptEngagementInvitationRequest>
  Model::AcceptEngagementInvitationOutcomeCallable AcceptEngagementInvitationCallable(
      const AcceptEngagementInvitationRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::AcceptEngagementInvitation, request);
  }
 
  template <typename AcceptEngagementInvitationRequestT = Model::AcceptEngagementInvitationRequest>
  void AcceptEngagementInvitationAsync(const AcceptEngagementInvitationRequestT& request,
                                       const AcceptEngagementInvitationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::AcceptEngagementInvitation, request, handler, context);
  }
 
  virtual Model::AssignOpportunityOutcome AssignOpportunity(const Model::AssignOpportunityRequest& request) const;
 
  template <typename AssignOpportunityRequestT = Model::AssignOpportunityRequest>
  Model::AssignOpportunityOutcomeCallable AssignOpportunityCallable(const AssignOpportunityRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::AssignOpportunity, request);
  }
 
  template <typename AssignOpportunityRequestT = Model::AssignOpportunityRequest>
  void AssignOpportunityAsync(const AssignOpportunityRequestT& request, const AssignOpportunityResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::AssignOpportunity, request, handler, context);
  }
 
  virtual Model::AssociateOpportunityOutcome AssociateOpportunity(const Model::AssociateOpportunityRequest& request) const;
 
  template <typename AssociateOpportunityRequestT = Model::AssociateOpportunityRequest>
  Model::AssociateOpportunityOutcomeCallable AssociateOpportunityCallable(const AssociateOpportunityRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::AssociateOpportunity, request);
  }
 
  template <typename AssociateOpportunityRequestT = Model::AssociateOpportunityRequest>
  void AssociateOpportunityAsync(const AssociateOpportunityRequestT& request, const AssociateOpportunityResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::AssociateOpportunity, request, handler, context);
  }
 
  virtual Model::CreateEngagementOutcome CreateEngagement(const Model::CreateEngagementRequest& request) const;
 
  template <typename CreateEngagementRequestT = Model::CreateEngagementRequest>
  Model::CreateEngagementOutcomeCallable CreateEngagementCallable(const CreateEngagementRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::CreateEngagement, request);
  }
 
  template <typename CreateEngagementRequestT = Model::CreateEngagementRequest>
  void CreateEngagementAsync(const CreateEngagementRequestT& request, const CreateEngagementResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::CreateEngagement, request, handler, context);
  }
 
  virtual Model::CreateEngagementContextOutcome CreateEngagementContext(const Model::CreateEngagementContextRequest& request) const;
 
  template <typename CreateEngagementContextRequestT = Model::CreateEngagementContextRequest>
  Model::CreateEngagementContextOutcomeCallable CreateEngagementContextCallable(const CreateEngagementContextRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::CreateEngagementContext, request);
  }
 
  template <typename CreateEngagementContextRequestT = Model::CreateEngagementContextRequest>
  void CreateEngagementContextAsync(const CreateEngagementContextRequestT& request,
                                    const CreateEngagementContextResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::CreateEngagementContext, request, handler, context);
  }
 
  virtual Model::CreateEngagementInvitationOutcome CreateEngagementInvitation(
      const Model::CreateEngagementInvitationRequest& request) const;
 
  template <typename CreateEngagementInvitationRequestT = Model::CreateEngagementInvitationRequest>
  Model::CreateEngagementInvitationOutcomeCallable CreateEngagementInvitationCallable(
      const CreateEngagementInvitationRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::CreateEngagementInvitation, request);
  }
 
  template <typename CreateEngagementInvitationRequestT = Model::CreateEngagementInvitationRequest>
  void CreateEngagementInvitationAsync(const CreateEngagementInvitationRequestT& request,
                                       const CreateEngagementInvitationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::CreateEngagementInvitation, request, handler, context);
  }
 
  virtual Model::CreateOpportunityOutcome CreateOpportunity(const Model::CreateOpportunityRequest& request) const;
 
  template <typename CreateOpportunityRequestT = Model::CreateOpportunityRequest>
  Model::CreateOpportunityOutcomeCallable CreateOpportunityCallable(const CreateOpportunityRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::CreateOpportunity, request);
  }
 
  template <typename CreateOpportunityRequestT = Model::CreateOpportunityRequest>
  void CreateOpportunityAsync(const CreateOpportunityRequestT& request, const CreateOpportunityResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::CreateOpportunity, request, handler, context);
  }
 
  virtual Model::CreateResourceSnapshotOutcome CreateResourceSnapshot(const Model::CreateResourceSnapshotRequest& request) const;
 
  template <typename CreateResourceSnapshotRequestT = Model::CreateResourceSnapshotRequest>
  Model::CreateResourceSnapshotOutcomeCallable CreateResourceSnapshotCallable(const CreateResourceSnapshotRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::CreateResourceSnapshot, request);
  }
 
  template <typename CreateResourceSnapshotRequestT = Model::CreateResourceSnapshotRequest>
  void CreateResourceSnapshotAsync(const CreateResourceSnapshotRequestT& request,
                                   const CreateResourceSnapshotResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::CreateResourceSnapshot, request, handler, context);
  }
 
  virtual Model::CreateResourceSnapshotJobOutcome CreateResourceSnapshotJob(const Model::CreateResourceSnapshotJobRequest& request) const;
 
  template <typename CreateResourceSnapshotJobRequestT = Model::CreateResourceSnapshotJobRequest>
  Model::CreateResourceSnapshotJobOutcomeCallable CreateResourceSnapshotJobCallable(
      const CreateResourceSnapshotJobRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::CreateResourceSnapshotJob, request);
  }
 
  template <typename CreateResourceSnapshotJobRequestT = Model::CreateResourceSnapshotJobRequest>
  void CreateResourceSnapshotJobAsync(const CreateResourceSnapshotJobRequestT& request,
                                      const CreateResourceSnapshotJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::CreateResourceSnapshotJob, request, handler, context);
  }
 
  virtual Model::DeleteResourceSnapshotJobOutcome DeleteResourceSnapshotJob(const Model::DeleteResourceSnapshotJobRequest& request) const;
 
  template <typename DeleteResourceSnapshotJobRequestT = Model::DeleteResourceSnapshotJobRequest>
  Model::DeleteResourceSnapshotJobOutcomeCallable DeleteResourceSnapshotJobCallable(
      const DeleteResourceSnapshotJobRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::DeleteResourceSnapshotJob, request);
  }
 
  template <typename DeleteResourceSnapshotJobRequestT = Model::DeleteResourceSnapshotJobRequest>
  void DeleteResourceSnapshotJobAsync(const DeleteResourceSnapshotJobRequestT& request,
                                      const DeleteResourceSnapshotJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::DeleteResourceSnapshotJob, request, handler, context);
  }
 
  virtual Model::DisassociateOpportunityOutcome DisassociateOpportunity(const Model::DisassociateOpportunityRequest& request) const;
 
  template <typename DisassociateOpportunityRequestT = Model::DisassociateOpportunityRequest>
  Model::DisassociateOpportunityOutcomeCallable DisassociateOpportunityCallable(const DisassociateOpportunityRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::DisassociateOpportunity, request);
  }
 
  template <typename DisassociateOpportunityRequestT = Model::DisassociateOpportunityRequest>
  void DisassociateOpportunityAsync(const DisassociateOpportunityRequestT& request,
                                    const DisassociateOpportunityResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::DisassociateOpportunity, request, handler, context);
  }
 
  virtual Model::GetAwsOpportunitySummaryOutcome GetAwsOpportunitySummary(const Model::GetAwsOpportunitySummaryRequest& request) const;
 
  template <typename GetAwsOpportunitySummaryRequestT = Model::GetAwsOpportunitySummaryRequest>
  Model::GetAwsOpportunitySummaryOutcomeCallable GetAwsOpportunitySummaryCallable(const GetAwsOpportunitySummaryRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::GetAwsOpportunitySummary, request);
  }
 
  template <typename GetAwsOpportunitySummaryRequestT = Model::GetAwsOpportunitySummaryRequest>
  void GetAwsOpportunitySummaryAsync(const GetAwsOpportunitySummaryRequestT& request,
                                     const GetAwsOpportunitySummaryResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::GetAwsOpportunitySummary, request, handler, context);
  }
 
  virtual Model::GetEngagementOutcome GetEngagement(const Model::GetEngagementRequest& request) const;
 
  template <typename GetEngagementRequestT = Model::GetEngagementRequest>
  Model::GetEngagementOutcomeCallable GetEngagementCallable(const GetEngagementRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::GetEngagement, request);
  }
 
  template <typename GetEngagementRequestT = Model::GetEngagementRequest>
  void GetEngagementAsync(const GetEngagementRequestT& request, const GetEngagementResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::GetEngagement, request, handler, context);
  }
 
  virtual Model::GetEngagementInvitationOutcome GetEngagementInvitation(const Model::GetEngagementInvitationRequest& request) const;
 
  template <typename GetEngagementInvitationRequestT = Model::GetEngagementInvitationRequest>
  Model::GetEngagementInvitationOutcomeCallable GetEngagementInvitationCallable(const GetEngagementInvitationRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::GetEngagementInvitation, request);
  }
 
  template <typename GetEngagementInvitationRequestT = Model::GetEngagementInvitationRequest>
  void GetEngagementInvitationAsync(const GetEngagementInvitationRequestT& request,
                                    const GetEngagementInvitationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::GetEngagementInvitation, request, handler, context);
  }
 
  virtual Model::GetOpportunityOutcome GetOpportunity(const Model::GetOpportunityRequest& request) const;
 
  template <typename GetOpportunityRequestT = Model::GetOpportunityRequest>
  Model::GetOpportunityOutcomeCallable GetOpportunityCallable(const GetOpportunityRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::GetOpportunity, request);
  }
 
  template <typename GetOpportunityRequestT = Model::GetOpportunityRequest>
  void GetOpportunityAsync(const GetOpportunityRequestT& request, const GetOpportunityResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::GetOpportunity, request, handler, context);
  }
 
  virtual Model::GetProspectingFromEngagementTaskOutcome GetProspectingFromEngagementTask(
      const Model::GetProspectingFromEngagementTaskRequest& request) const;
 
  template <typename GetProspectingFromEngagementTaskRequestT = Model::GetProspectingFromEngagementTaskRequest>
  Model::GetProspectingFromEngagementTaskOutcomeCallable GetProspectingFromEngagementTaskCallable(
      const GetProspectingFromEngagementTaskRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::GetProspectingFromEngagementTask, request);
  }
 
  template <typename GetProspectingFromEngagementTaskRequestT = Model::GetProspectingFromEngagementTaskRequest>
  void GetProspectingFromEngagementTaskAsync(const GetProspectingFromEngagementTaskRequestT& request,
                                             const GetProspectingFromEngagementTaskResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::GetProspectingFromEngagementTask, request, handler, context);
  }
 
  virtual Model::GetResourceSnapshotOutcome GetResourceSnapshot(const Model::GetResourceSnapshotRequest& request) const;
 
  template <typename GetResourceSnapshotRequestT = Model::GetResourceSnapshotRequest>
  Model::GetResourceSnapshotOutcomeCallable GetResourceSnapshotCallable(const GetResourceSnapshotRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::GetResourceSnapshot, request);
  }
 
  template <typename GetResourceSnapshotRequestT = Model::GetResourceSnapshotRequest>
  void GetResourceSnapshotAsync(const GetResourceSnapshotRequestT& request, const GetResourceSnapshotResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::GetResourceSnapshot, request, handler, context);
  }
 
  virtual Model::GetResourceSnapshotJobOutcome GetResourceSnapshotJob(const Model::GetResourceSnapshotJobRequest& request) const;
 
  template <typename GetResourceSnapshotJobRequestT = Model::GetResourceSnapshotJobRequest>
  Model::GetResourceSnapshotJobOutcomeCallable GetResourceSnapshotJobCallable(const GetResourceSnapshotJobRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::GetResourceSnapshotJob, request);
  }
 
  template <typename GetResourceSnapshotJobRequestT = Model::GetResourceSnapshotJobRequest>
  void GetResourceSnapshotJobAsync(const GetResourceSnapshotJobRequestT& request,
                                   const GetResourceSnapshotJobResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::GetResourceSnapshotJob, request, handler, context);
  }
 
  virtual Model::GetSellingSystemSettingsOutcome GetSellingSystemSettings(const Model::GetSellingSystemSettingsRequest& request) const;
 
  template <typename GetSellingSystemSettingsRequestT = Model::GetSellingSystemSettingsRequest>
  Model::GetSellingSystemSettingsOutcomeCallable GetSellingSystemSettingsCallable(const GetSellingSystemSettingsRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::GetSellingSystemSettings, request);
  }
 
  template <typename GetSellingSystemSettingsRequestT = Model::GetSellingSystemSettingsRequest>
  void GetSellingSystemSettingsAsync(const GetSellingSystemSettingsRequestT& request,
                                     const GetSellingSystemSettingsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::GetSellingSystemSettings, request, handler, context);
  }
 
  virtual Model::ListEngagementByAcceptingInvitationTasksOutcome ListEngagementByAcceptingInvitationTasks(
      const Model::ListEngagementByAcceptingInvitationTasksRequest& request) const;
 
  template <typename ListEngagementByAcceptingInvitationTasksRequestT = Model::ListEngagementByAcceptingInvitationTasksRequest>
  Model::ListEngagementByAcceptingInvitationTasksOutcomeCallable ListEngagementByAcceptingInvitationTasksCallable(
      const ListEngagementByAcceptingInvitationTasksRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListEngagementByAcceptingInvitationTasks, request);
  }
 
  template <typename ListEngagementByAcceptingInvitationTasksRequestT = Model::ListEngagementByAcceptingInvitationTasksRequest>
  void ListEngagementByAcceptingInvitationTasksAsync(
      const ListEngagementByAcceptingInvitationTasksRequestT& request,
      const ListEngagementByAcceptingInvitationTasksResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListEngagementByAcceptingInvitationTasks, request, handler, context);
  }
 
  virtual Model::ListEngagementFromOpportunityTasksOutcome ListEngagementFromOpportunityTasks(
      const Model::ListEngagementFromOpportunityTasksRequest& request) const;
 
  template <typename ListEngagementFromOpportunityTasksRequestT = Model::ListEngagementFromOpportunityTasksRequest>
  Model::ListEngagementFromOpportunityTasksOutcomeCallable ListEngagementFromOpportunityTasksCallable(
      const ListEngagementFromOpportunityTasksRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListEngagementFromOpportunityTasks, request);
  }
 
  template <typename ListEngagementFromOpportunityTasksRequestT = Model::ListEngagementFromOpportunityTasksRequest>
  void ListEngagementFromOpportunityTasksAsync(const ListEngagementFromOpportunityTasksRequestT& request,
                                               const ListEngagementFromOpportunityTasksResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListEngagementFromOpportunityTasks, request, handler, context);
  }
 
  virtual Model::ListEngagementInvitationsOutcome ListEngagementInvitations(const Model::ListEngagementInvitationsRequest& request) const;
 
  template <typename ListEngagementInvitationsRequestT = Model::ListEngagementInvitationsRequest>
  Model::ListEngagementInvitationsOutcomeCallable ListEngagementInvitationsCallable(
      const ListEngagementInvitationsRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListEngagementInvitations, request);
  }
 
  template <typename ListEngagementInvitationsRequestT = Model::ListEngagementInvitationsRequest>
  void ListEngagementInvitationsAsync(const ListEngagementInvitationsRequestT& request,
                                      const ListEngagementInvitationsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListEngagementInvitations, request, handler, context);
  }
 
  virtual Model::ListEngagementMembersOutcome ListEngagementMembers(const Model::ListEngagementMembersRequest& request) const;
 
  template <typename ListEngagementMembersRequestT = Model::ListEngagementMembersRequest>
  Model::ListEngagementMembersOutcomeCallable ListEngagementMembersCallable(const ListEngagementMembersRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListEngagementMembers, request);
  }
 
  template <typename ListEngagementMembersRequestT = Model::ListEngagementMembersRequest>
  void ListEngagementMembersAsync(const ListEngagementMembersRequestT& request, const ListEngagementMembersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListEngagementMembers, request, handler, context);
  }
 
  virtual Model::ListEngagementResourceAssociationsOutcome ListEngagementResourceAssociations(
      const Model::ListEngagementResourceAssociationsRequest& request) const;
 
  template <typename ListEngagementResourceAssociationsRequestT = Model::ListEngagementResourceAssociationsRequest>
  Model::ListEngagementResourceAssociationsOutcomeCallable ListEngagementResourceAssociationsCallable(
      const ListEngagementResourceAssociationsRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListEngagementResourceAssociations, request);
  }
 
  template <typename ListEngagementResourceAssociationsRequestT = Model::ListEngagementResourceAssociationsRequest>
  void ListEngagementResourceAssociationsAsync(const ListEngagementResourceAssociationsRequestT& request,
                                               const ListEngagementResourceAssociationsResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListEngagementResourceAssociations, request, handler, context);
  }
 
  virtual Model::ListEngagementsOutcome ListEngagements(const Model::ListEngagementsRequest& request) const;
 
  template <typename ListEngagementsRequestT = Model::ListEngagementsRequest>
  Model::ListEngagementsOutcomeCallable ListEngagementsCallable(const ListEngagementsRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListEngagements, request);
  }
 
  template <typename ListEngagementsRequestT = Model::ListEngagementsRequest>
  void ListEngagementsAsync(const ListEngagementsRequestT& request, const ListEngagementsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListEngagements, request, handler, context);
  }
 
  virtual Model::ListOpportunitiesOutcome ListOpportunities(const Model::ListOpportunitiesRequest& request) const;
 
  template <typename ListOpportunitiesRequestT = Model::ListOpportunitiesRequest>
  Model::ListOpportunitiesOutcomeCallable ListOpportunitiesCallable(const ListOpportunitiesRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListOpportunities, request);
  }
 
  template <typename ListOpportunitiesRequestT = Model::ListOpportunitiesRequest>
  void ListOpportunitiesAsync(const ListOpportunitiesRequestT& request, const ListOpportunitiesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListOpportunities, request, handler, context);
  }
 
  virtual Model::ListOpportunityFromEngagementTasksOutcome ListOpportunityFromEngagementTasks(
      const Model::ListOpportunityFromEngagementTasksRequest& request) const;
 
  template <typename ListOpportunityFromEngagementTasksRequestT = Model::ListOpportunityFromEngagementTasksRequest>
  Model::ListOpportunityFromEngagementTasksOutcomeCallable ListOpportunityFromEngagementTasksCallable(
      const ListOpportunityFromEngagementTasksRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListOpportunityFromEngagementTasks, request);
  }
 
  template <typename ListOpportunityFromEngagementTasksRequestT = Model::ListOpportunityFromEngagementTasksRequest>
  void ListOpportunityFromEngagementTasksAsync(const ListOpportunityFromEngagementTasksRequestT& request,
                                               const ListOpportunityFromEngagementTasksResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListOpportunityFromEngagementTasks, request, handler, context);
  }
 
  virtual Model::ListProspectingFromEngagementTasksOutcome ListProspectingFromEngagementTasks(
      const Model::ListProspectingFromEngagementTasksRequest& request) const;
 
  template <typename ListProspectingFromEngagementTasksRequestT = Model::ListProspectingFromEngagementTasksRequest>
  Model::ListProspectingFromEngagementTasksOutcomeCallable ListProspectingFromEngagementTasksCallable(
      const ListProspectingFromEngagementTasksRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListProspectingFromEngagementTasks, request);
  }
 
  template <typename ListProspectingFromEngagementTasksRequestT = Model::ListProspectingFromEngagementTasksRequest>
  void ListProspectingFromEngagementTasksAsync(const ListProspectingFromEngagementTasksRequestT& request,
                                               const ListProspectingFromEngagementTasksResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListProspectingFromEngagementTasks, request, handler, context);
  }
 
  virtual Model::ListResourceSnapshotJobsOutcome ListResourceSnapshotJobs(const Model::ListResourceSnapshotJobsRequest& request) const;
 
  template <typename ListResourceSnapshotJobsRequestT = Model::ListResourceSnapshotJobsRequest>
  Model::ListResourceSnapshotJobsOutcomeCallable ListResourceSnapshotJobsCallable(const ListResourceSnapshotJobsRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListResourceSnapshotJobs, request);
  }
 
  template <typename ListResourceSnapshotJobsRequestT = Model::ListResourceSnapshotJobsRequest>
  void ListResourceSnapshotJobsAsync(const ListResourceSnapshotJobsRequestT& request,
                                     const ListResourceSnapshotJobsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListResourceSnapshotJobs, request, handler, context);
  }
 
  virtual Model::ListResourceSnapshotsOutcome ListResourceSnapshots(const Model::ListResourceSnapshotsRequest& request) const;
 
  template <typename ListResourceSnapshotsRequestT = Model::ListResourceSnapshotsRequest>
  Model::ListResourceSnapshotsOutcomeCallable ListResourceSnapshotsCallable(const ListResourceSnapshotsRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListResourceSnapshots, request);
  }
 
  template <typename ListResourceSnapshotsRequestT = Model::ListResourceSnapshotsRequest>
  void ListResourceSnapshotsAsync(const ListResourceSnapshotsRequestT& request, const ListResourceSnapshotsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListResourceSnapshots, request, handler, context);
  }
 
  virtual Model::ListSolutionsOutcome ListSolutions(const Model::ListSolutionsRequest& request) const;
 
  template <typename ListSolutionsRequestT = Model::ListSolutionsRequest>
  Model::ListSolutionsOutcomeCallable ListSolutionsCallable(const ListSolutionsRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::ListSolutions, request);
  }
 
  template <typename ListSolutionsRequestT = Model::ListSolutionsRequest>
  void ListSolutionsAsync(const ListSolutionsRequestT& request, const ListSolutionsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::ListSolutions, 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(&PartnerCentralSellingClient::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(&PartnerCentralSellingClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutSellingSystemSettingsOutcome PutSellingSystemSettings(const Model::PutSellingSystemSettingsRequest& request) const;
 
  template <typename PutSellingSystemSettingsRequestT = Model::PutSellingSystemSettingsRequest>
  Model::PutSellingSystemSettingsOutcomeCallable PutSellingSystemSettingsCallable(const PutSellingSystemSettingsRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::PutSellingSystemSettings, request);
  }
 
  template <typename PutSellingSystemSettingsRequestT = Model::PutSellingSystemSettingsRequest>
  void PutSellingSystemSettingsAsync(const PutSellingSystemSettingsRequestT& request,
                                     const PutSellingSystemSettingsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::PutSellingSystemSettings, request, handler, context);
  }
 
  virtual Model::RejectEngagementInvitationOutcome RejectEngagementInvitation(
      const Model::RejectEngagementInvitationRequest& request) const;
 
  template <typename RejectEngagementInvitationRequestT = Model::RejectEngagementInvitationRequest>
  Model::RejectEngagementInvitationOutcomeCallable RejectEngagementInvitationCallable(
      const RejectEngagementInvitationRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::RejectEngagementInvitation, request);
  }
 
  template <typename RejectEngagementInvitationRequestT = Model::RejectEngagementInvitationRequest>
  void RejectEngagementInvitationAsync(const RejectEngagementInvitationRequestT& request,
                                       const RejectEngagementInvitationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::RejectEngagementInvitation, request, handler, context);
  }
 
  virtual Model::StartEngagementByAcceptingInvitationTaskOutcome StartEngagementByAcceptingInvitationTask(
      const Model::StartEngagementByAcceptingInvitationTaskRequest& request) const;
 
  template <typename StartEngagementByAcceptingInvitationTaskRequestT = Model::StartEngagementByAcceptingInvitationTaskRequest>
  Model::StartEngagementByAcceptingInvitationTaskOutcomeCallable StartEngagementByAcceptingInvitationTaskCallable(
      const StartEngagementByAcceptingInvitationTaskRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::StartEngagementByAcceptingInvitationTask, request);
  }
 
  template <typename StartEngagementByAcceptingInvitationTaskRequestT = Model::StartEngagementByAcceptingInvitationTaskRequest>
  void StartEngagementByAcceptingInvitationTaskAsync(
      const StartEngagementByAcceptingInvitationTaskRequestT& request,
      const StartEngagementByAcceptingInvitationTaskResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::StartEngagementByAcceptingInvitationTask, request, handler, context);
  }
 
  virtual Model::StartEngagementFromOpportunityTaskOutcome StartEngagementFromOpportunityTask(
      const Model::StartEngagementFromOpportunityTaskRequest& request) const;
 
  template <typename StartEngagementFromOpportunityTaskRequestT = Model::StartEngagementFromOpportunityTaskRequest>
  Model::StartEngagementFromOpportunityTaskOutcomeCallable StartEngagementFromOpportunityTaskCallable(
      const StartEngagementFromOpportunityTaskRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::StartEngagementFromOpportunityTask, request);
  }
 
  template <typename StartEngagementFromOpportunityTaskRequestT = Model::StartEngagementFromOpportunityTaskRequest>
  void StartEngagementFromOpportunityTaskAsync(const StartEngagementFromOpportunityTaskRequestT& request,
                                               const StartEngagementFromOpportunityTaskResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::StartEngagementFromOpportunityTask, request, handler, context);
  }
 
  virtual Model::StartOpportunityFromEngagementTaskOutcome StartOpportunityFromEngagementTask(
      const Model::StartOpportunityFromEngagementTaskRequest& request) const;
 
  template <typename StartOpportunityFromEngagementTaskRequestT = Model::StartOpportunityFromEngagementTaskRequest>
  Model::StartOpportunityFromEngagementTaskOutcomeCallable StartOpportunityFromEngagementTaskCallable(
      const StartOpportunityFromEngagementTaskRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::StartOpportunityFromEngagementTask, request);
  }
 
  template <typename StartOpportunityFromEngagementTaskRequestT = Model::StartOpportunityFromEngagementTaskRequest>
  void StartOpportunityFromEngagementTaskAsync(const StartOpportunityFromEngagementTaskRequestT& request,
                                               const StartOpportunityFromEngagementTaskResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::StartOpportunityFromEngagementTask, request, handler, context);
  }
 
  virtual Model::StartProspectingFromEngagementTaskOutcome StartProspectingFromEngagementTask(
      const Model::StartProspectingFromEngagementTaskRequest& request) const;
 
  template <typename StartProspectingFromEngagementTaskRequestT = Model::StartProspectingFromEngagementTaskRequest>
  Model::StartProspectingFromEngagementTaskOutcomeCallable StartProspectingFromEngagementTaskCallable(
      const StartProspectingFromEngagementTaskRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::StartProspectingFromEngagementTask, request);
  }
 
  template <typename StartProspectingFromEngagementTaskRequestT = Model::StartProspectingFromEngagementTaskRequest>
  void StartProspectingFromEngagementTaskAsync(const StartProspectingFromEngagementTaskRequestT& request,
                                               const StartProspectingFromEngagementTaskResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::StartProspectingFromEngagementTask, request, handler, context);
  }
 
  virtual Model::StartResourceSnapshotJobOutcome StartResourceSnapshotJob(const Model::StartResourceSnapshotJobRequest& request) const;
 
  template <typename StartResourceSnapshotJobRequestT = Model::StartResourceSnapshotJobRequest>
  Model::StartResourceSnapshotJobOutcomeCallable StartResourceSnapshotJobCallable(const StartResourceSnapshotJobRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::StartResourceSnapshotJob, request);
  }
 
  template <typename StartResourceSnapshotJobRequestT = Model::StartResourceSnapshotJobRequest>
  void StartResourceSnapshotJobAsync(const StartResourceSnapshotJobRequestT& request,
                                     const StartResourceSnapshotJobResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::StartResourceSnapshotJob, request, handler, context);
  }
 
  virtual Model::StopResourceSnapshotJobOutcome StopResourceSnapshotJob(const Model::StopResourceSnapshotJobRequest& request) const;
 
  template <typename StopResourceSnapshotJobRequestT = Model::StopResourceSnapshotJobRequest>
  Model::StopResourceSnapshotJobOutcomeCallable StopResourceSnapshotJobCallable(const StopResourceSnapshotJobRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::StopResourceSnapshotJob, request);
  }
 
  template <typename StopResourceSnapshotJobRequestT = Model::StopResourceSnapshotJobRequest>
  void StopResourceSnapshotJobAsync(const StopResourceSnapshotJobRequestT& request,
                                    const StopResourceSnapshotJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::StopResourceSnapshotJob, request, handler, context);
  }
 
  virtual Model::SubmitOpportunityOutcome SubmitOpportunity(const Model::SubmitOpportunityRequest& request) const;
 
  template <typename SubmitOpportunityRequestT = Model::SubmitOpportunityRequest>
  Model::SubmitOpportunityOutcomeCallable SubmitOpportunityCallable(const SubmitOpportunityRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::SubmitOpportunity, request);
  }
 
  template <typename SubmitOpportunityRequestT = Model::SubmitOpportunityRequest>
  void SubmitOpportunityAsync(const SubmitOpportunityRequestT& request, const SubmitOpportunityResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::SubmitOpportunity, 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(&PartnerCentralSellingClient::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(&PartnerCentralSellingClient::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(&PartnerCentralSellingClient::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(&PartnerCentralSellingClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateEngagementContextOutcome UpdateEngagementContext(const Model::UpdateEngagementContextRequest& request) const;
 
  template <typename UpdateEngagementContextRequestT = Model::UpdateEngagementContextRequest>
  Model::UpdateEngagementContextOutcomeCallable UpdateEngagementContextCallable(const UpdateEngagementContextRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::UpdateEngagementContext, request);
  }
 
  template <typename UpdateEngagementContextRequestT = Model::UpdateEngagementContextRequest>
  void UpdateEngagementContextAsync(const UpdateEngagementContextRequestT& request,
                                    const UpdateEngagementContextResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::UpdateEngagementContext, request, handler, context);
  }
 
  virtual Model::UpdateOpportunityOutcome UpdateOpportunity(const Model::UpdateOpportunityRequest& request) const;
 
  template <typename UpdateOpportunityRequestT = Model::UpdateOpportunityRequest>
  Model::UpdateOpportunityOutcomeCallable UpdateOpportunityCallable(const UpdateOpportunityRequestT& request) const {
    return SubmitCallable(&PartnerCentralSellingClient::UpdateOpportunity, request);
  }
 
  template <typename UpdateOpportunityRequestT = Model::UpdateOpportunityRequest>
  void UpdateOpportunityAsync(const UpdateOpportunityRequestT& request, const UpdateOpportunityResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PartnerCentralSellingClient::UpdateOpportunity, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PartnerCentralSellingEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PartnerCentralSellingClient>;
  void init(const PartnerCentralSellingClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, PartnerCentralSellingError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  PartnerCentralSellingClientConfiguration m_clientConfiguration;
  std::shared_ptr<PartnerCentralSellingEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace PartnerCentralSelling
}  // namespace Aws