PartnerCentralSellingClient.h

 
#pragma once
#include <aws/partnercentral-selling/PartnerCentralSelling_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/partnercentral-selling/PartnerCentralSellingServiceClientModel.h>
 
namespace Aws
{
namespace PartnerCentralSelling
{
  class AWS_PARTNERCENTRALSELLING_API PartnerCentralSellingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<PartnerCentralSellingEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<PartnerCentralSellingClient>;
      void init(const PartnerCentralSellingClientConfiguration& clientConfiguration);
 
      PartnerCentralSellingClientConfiguration m_clientConfiguration;
      std::shared_ptr<PartnerCentralSellingEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace PartnerCentralSelling
} // namespace Aws