MPAClient.h

 
#pragma once
#include <aws/mpa/MPA_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/mpa/MPAServiceClientModel.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