MPAClient.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/mpa/MPAServiceClientModel.h>
#include <aws/mpa/MPA_EXPORTS.h>
 
namespace Aws {
namespace MPA {
class AWS_MPA_API MPAClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<MPAClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef MPAClientConfiguration ClientConfigurationType;
  typedef MPAEndpointProvider EndpointProviderType;
 
  MPAClient(const Aws::MPA::MPAClientConfiguration& clientConfiguration = Aws::MPA::MPAClientConfiguration(),
            std::shared_ptr<MPAEndpointProviderBase> endpointProvider = nullptr);
 
  MPAClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<MPAEndpointProviderBase> endpointProvider = nullptr,
            const Aws::MPA::MPAClientConfiguration& clientConfiguration = Aws::MPA::MPAClientConfiguration());
 
  MPAClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<MPAEndpointProviderBase> endpointProvider = nullptr,
            const Aws::MPA::MPAClientConfiguration& clientConfiguration = Aws::MPA::MPAClientConfiguration());
 
  /* Legacy constructors due deprecation */
  MPAClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MPAClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MPAClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~MPAClient();
 
  virtual Model::CancelSessionOutcome CancelSession(const Model::CancelSessionRequest& request) const;
 
  template <typename CancelSessionRequestT = Model::CancelSessionRequest>
  Model::CancelSessionOutcomeCallable CancelSessionCallable(const CancelSessionRequestT& request) const {
    return SubmitCallable(&MPAClient::CancelSession, request);
  }
 
  template <typename CancelSessionRequestT = Model::CancelSessionRequest>
  void CancelSessionAsync(const CancelSessionRequestT& request, const CancelSessionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::CancelSession, request, handler, context);
  }
 
  virtual Model::CreateApprovalTeamOutcome CreateApprovalTeam(const Model::CreateApprovalTeamRequest& request) const;
 
  template <typename CreateApprovalTeamRequestT = Model::CreateApprovalTeamRequest>
  Model::CreateApprovalTeamOutcomeCallable CreateApprovalTeamCallable(const CreateApprovalTeamRequestT& request) const {
    return SubmitCallable(&MPAClient::CreateApprovalTeam, request);
  }
 
  template <typename CreateApprovalTeamRequestT = Model::CreateApprovalTeamRequest>
  void CreateApprovalTeamAsync(const CreateApprovalTeamRequestT& request, const CreateApprovalTeamResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::CreateApprovalTeam, request, handler, context);
  }
 
  virtual Model::CreateIdentitySourceOutcome CreateIdentitySource(const Model::CreateIdentitySourceRequest& request) const;
 
  template <typename CreateIdentitySourceRequestT = Model::CreateIdentitySourceRequest>
  Model::CreateIdentitySourceOutcomeCallable CreateIdentitySourceCallable(const CreateIdentitySourceRequestT& request) const {
    return SubmitCallable(&MPAClient::CreateIdentitySource, request);
  }
 
  template <typename CreateIdentitySourceRequestT = Model::CreateIdentitySourceRequest>
  void CreateIdentitySourceAsync(const CreateIdentitySourceRequestT& request, const CreateIdentitySourceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::CreateIdentitySource, request, handler, context);
  }
 
  virtual Model::DeleteIdentitySourceOutcome DeleteIdentitySource(const Model::DeleteIdentitySourceRequest& request) const;
 
  template <typename DeleteIdentitySourceRequestT = Model::DeleteIdentitySourceRequest>
  Model::DeleteIdentitySourceOutcomeCallable DeleteIdentitySourceCallable(const DeleteIdentitySourceRequestT& request) const {
    return SubmitCallable(&MPAClient::DeleteIdentitySource, request);
  }
 
  template <typename DeleteIdentitySourceRequestT = Model::DeleteIdentitySourceRequest>
  void DeleteIdentitySourceAsync(const DeleteIdentitySourceRequestT& request, const DeleteIdentitySourceResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::DeleteIdentitySource, request, handler, context);
  }
 
  virtual Model::DeleteInactiveApprovalTeamVersionOutcome DeleteInactiveApprovalTeamVersion(
      const Model::DeleteInactiveApprovalTeamVersionRequest& request) const;
 
  template <typename DeleteInactiveApprovalTeamVersionRequestT = Model::DeleteInactiveApprovalTeamVersionRequest>
  Model::DeleteInactiveApprovalTeamVersionOutcomeCallable DeleteInactiveApprovalTeamVersionCallable(
      const DeleteInactiveApprovalTeamVersionRequestT& request) const {
    return SubmitCallable(&MPAClient::DeleteInactiveApprovalTeamVersion, request);
  }
 
  template <typename DeleteInactiveApprovalTeamVersionRequestT = Model::DeleteInactiveApprovalTeamVersionRequest>
  void DeleteInactiveApprovalTeamVersionAsync(const DeleteInactiveApprovalTeamVersionRequestT& request,
                                              const DeleteInactiveApprovalTeamVersionResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::DeleteInactiveApprovalTeamVersion, request, handler, context);
  }
 
  virtual Model::GetApprovalTeamOutcome GetApprovalTeam(const Model::GetApprovalTeamRequest& request) const;
 
  template <typename GetApprovalTeamRequestT = Model::GetApprovalTeamRequest>
  Model::GetApprovalTeamOutcomeCallable GetApprovalTeamCallable(const GetApprovalTeamRequestT& request) const {
    return SubmitCallable(&MPAClient::GetApprovalTeam, request);
  }
 
  template <typename GetApprovalTeamRequestT = Model::GetApprovalTeamRequest>
  void GetApprovalTeamAsync(const GetApprovalTeamRequestT& request, const GetApprovalTeamResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::GetApprovalTeam, request, handler, context);
  }
 
  virtual Model::GetIdentitySourceOutcome GetIdentitySource(const Model::GetIdentitySourceRequest& request) const;
 
  template <typename GetIdentitySourceRequestT = Model::GetIdentitySourceRequest>
  Model::GetIdentitySourceOutcomeCallable GetIdentitySourceCallable(const GetIdentitySourceRequestT& request) const {
    return SubmitCallable(&MPAClient::GetIdentitySource, request);
  }
 
  template <typename GetIdentitySourceRequestT = Model::GetIdentitySourceRequest>
  void GetIdentitySourceAsync(const GetIdentitySourceRequestT& request, const GetIdentitySourceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::GetIdentitySource, request, handler, context);
  }
 
  virtual Model::GetPolicyVersionOutcome GetPolicyVersion(const Model::GetPolicyVersionRequest& request) const;
 
  template <typename GetPolicyVersionRequestT = Model::GetPolicyVersionRequest>
  Model::GetPolicyVersionOutcomeCallable GetPolicyVersionCallable(const GetPolicyVersionRequestT& request) const {
    return SubmitCallable(&MPAClient::GetPolicyVersion, request);
  }
 
  template <typename GetPolicyVersionRequestT = Model::GetPolicyVersionRequest>
  void GetPolicyVersionAsync(const GetPolicyVersionRequestT& request, const GetPolicyVersionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::GetPolicyVersion, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&MPAClient::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::GetSessionOutcome GetSession(const Model::GetSessionRequest& request) const;
 
  template <typename GetSessionRequestT = Model::GetSessionRequest>
  Model::GetSessionOutcomeCallable GetSessionCallable(const GetSessionRequestT& request) const {
    return SubmitCallable(&MPAClient::GetSession, request);
  }
 
  template <typename GetSessionRequestT = Model::GetSessionRequest>
  void GetSessionAsync(const GetSessionRequestT& request, const GetSessionResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::GetSession, request, handler, context);
  }
 
  virtual Model::ListApprovalTeamsOutcome ListApprovalTeams(const Model::ListApprovalTeamsRequest& request = {}) const;
 
  template <typename ListApprovalTeamsRequestT = Model::ListApprovalTeamsRequest>
  Model::ListApprovalTeamsOutcomeCallable ListApprovalTeamsCallable(const ListApprovalTeamsRequestT& request = {}) const {
    return SubmitCallable(&MPAClient::ListApprovalTeams, request);
  }
 
  template <typename ListApprovalTeamsRequestT = Model::ListApprovalTeamsRequest>
  void ListApprovalTeamsAsync(const ListApprovalTeamsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListApprovalTeamsRequestT& request = {}) const {
    return SubmitAsync(&MPAClient::ListApprovalTeams, request, handler, context);
  }
 
  virtual Model::ListIdentitySourcesOutcome ListIdentitySources(const Model::ListIdentitySourcesRequest& request = {}) const;
 
  template <typename ListIdentitySourcesRequestT = Model::ListIdentitySourcesRequest>
  Model::ListIdentitySourcesOutcomeCallable ListIdentitySourcesCallable(const ListIdentitySourcesRequestT& request = {}) const {
    return SubmitCallable(&MPAClient::ListIdentitySources, request);
  }
 
  template <typename ListIdentitySourcesRequestT = Model::ListIdentitySourcesRequest>
  void ListIdentitySourcesAsync(const ListIdentitySourcesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListIdentitySourcesRequestT& request = {}) const {
    return SubmitAsync(&MPAClient::ListIdentitySources, request, handler, context);
  }
 
  virtual Model::ListPoliciesOutcome ListPolicies(const Model::ListPoliciesRequest& request = {}) const;
 
  template <typename ListPoliciesRequestT = Model::ListPoliciesRequest>
  Model::ListPoliciesOutcomeCallable ListPoliciesCallable(const ListPoliciesRequestT& request = {}) const {
    return SubmitCallable(&MPAClient::ListPolicies, request);
  }
 
  template <typename ListPoliciesRequestT = Model::ListPoliciesRequest>
  void ListPoliciesAsync(const ListPoliciesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListPoliciesRequestT& request = {}) const {
    return SubmitAsync(&MPAClient::ListPolicies, request, handler, context);
  }
 
  virtual Model::ListPolicyVersionsOutcome ListPolicyVersions(const Model::ListPolicyVersionsRequest& request) const;
 
  template <typename ListPolicyVersionsRequestT = Model::ListPolicyVersionsRequest>
  Model::ListPolicyVersionsOutcomeCallable ListPolicyVersionsCallable(const ListPolicyVersionsRequestT& request) const {
    return SubmitCallable(&MPAClient::ListPolicyVersions, request);
  }
 
  template <typename ListPolicyVersionsRequestT = Model::ListPolicyVersionsRequest>
  void ListPolicyVersionsAsync(const ListPolicyVersionsRequestT& request, const ListPolicyVersionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::ListPolicyVersions, request, handler, context);
  }
 
  virtual Model::ListResourcePoliciesOutcome ListResourcePolicies(const Model::ListResourcePoliciesRequest& request) const;
 
  template <typename ListResourcePoliciesRequestT = Model::ListResourcePoliciesRequest>
  Model::ListResourcePoliciesOutcomeCallable ListResourcePoliciesCallable(const ListResourcePoliciesRequestT& request) const {
    return SubmitCallable(&MPAClient::ListResourcePolicies, request);
  }
 
  template <typename ListResourcePoliciesRequestT = Model::ListResourcePoliciesRequest>
  void ListResourcePoliciesAsync(const ListResourcePoliciesRequestT& request, const ListResourcePoliciesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::ListResourcePolicies, request, handler, context);
  }
 
  virtual Model::ListSessionsOutcome ListSessions(const Model::ListSessionsRequest& request) const;
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  Model::ListSessionsOutcomeCallable ListSessionsCallable(const ListSessionsRequestT& request) const {
    return SubmitCallable(&MPAClient::ListSessions, request);
  }
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  void ListSessionsAsync(const ListSessionsRequestT& request, const ListSessionsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::ListSessions, 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(&MPAClient::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(&MPAClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::StartActiveApprovalTeamDeletionOutcome StartActiveApprovalTeamDeletion(
      const Model::StartActiveApprovalTeamDeletionRequest& request) const;
 
  template <typename StartActiveApprovalTeamDeletionRequestT = Model::StartActiveApprovalTeamDeletionRequest>
  Model::StartActiveApprovalTeamDeletionOutcomeCallable StartActiveApprovalTeamDeletionCallable(
      const StartActiveApprovalTeamDeletionRequestT& request) const {
    return SubmitCallable(&MPAClient::StartActiveApprovalTeamDeletion, request);
  }
 
  template <typename StartActiveApprovalTeamDeletionRequestT = Model::StartActiveApprovalTeamDeletionRequest>
  void StartActiveApprovalTeamDeletionAsync(const StartActiveApprovalTeamDeletionRequestT& request,
                                            const StartActiveApprovalTeamDeletionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::StartActiveApprovalTeamDeletion, 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(&MPAClient::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(&MPAClient::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(&MPAClient::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(&MPAClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateApprovalTeamOutcome UpdateApprovalTeam(const Model::UpdateApprovalTeamRequest& request) const;
 
  template <typename UpdateApprovalTeamRequestT = Model::UpdateApprovalTeamRequest>
  Model::UpdateApprovalTeamOutcomeCallable UpdateApprovalTeamCallable(const UpdateApprovalTeamRequestT& request) const {
    return SubmitCallable(&MPAClient::UpdateApprovalTeam, request);
  }
 
  template <typename UpdateApprovalTeamRequestT = Model::UpdateApprovalTeamRequest>
  void UpdateApprovalTeamAsync(const UpdateApprovalTeamRequestT& request, const UpdateApprovalTeamResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MPAClient::UpdateApprovalTeam, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<MPAEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MPAClient>;
  void init(const MPAClientConfiguration& clientConfiguration);
 
  MPAClientConfiguration m_clientConfiguration;
  std::shared_ptr<MPAEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace MPA
}  // namespace Aws