STSClient.h

 
#pragma once
#include <aws/sts/STS_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/sts/STSServiceClientModel.h>
 
namespace Aws
{
namespace STS
{
  class AWS_STS_API STSClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<STSClient>
  {
    public:
      typedef Aws::Client::AWSXMLClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef STSClientConfiguration ClientConfigurationType;
      typedef STSEndpointProvider EndpointProviderType;
 
        STSClient(const Aws::STS::STSClientConfiguration& clientConfiguration = Aws::STS::STSClientConfiguration(),
                  std::shared_ptr<STSEndpointProviderBase> endpointProvider = nullptr);
 
        STSClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<STSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::STS::STSClientConfiguration& clientConfiguration = Aws::STS::STSClientConfiguration());
 
        STSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<STSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::STS::STSClientConfiguration& clientConfiguration = Aws::STS::STSClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        STSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        STSClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        STSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~STSClient();
 
 
        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
 
        virtual Model::AssumeRoleOutcome AssumeRole(const Model::AssumeRoleRequest& request) const;
 
        template<typename AssumeRoleRequestT = Model::AssumeRoleRequest>
        Model::AssumeRoleOutcomeCallable AssumeRoleCallable(const AssumeRoleRequestT& request) const
        {
            return SubmitCallable(&STSClient::AssumeRole, request);
        }
 
        template<typename AssumeRoleRequestT = Model::AssumeRoleRequest>
        void AssumeRoleAsync(const AssumeRoleRequestT& request, const AssumeRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&STSClient::AssumeRole, request, handler, context);
        }
 
        virtual Model::AssumeRoleWithSAMLOutcome AssumeRoleWithSAML(const Model::AssumeRoleWithSAMLRequest& request) const;
 
        template<typename AssumeRoleWithSAMLRequestT = Model::AssumeRoleWithSAMLRequest>
        Model::AssumeRoleWithSAMLOutcomeCallable AssumeRoleWithSAMLCallable(const AssumeRoleWithSAMLRequestT& request) const
        {
            return SubmitCallable(&STSClient::AssumeRoleWithSAML, request);
        }
 
        template<typename AssumeRoleWithSAMLRequestT = Model::AssumeRoleWithSAMLRequest>
        void AssumeRoleWithSAMLAsync(const AssumeRoleWithSAMLRequestT& request, const AssumeRoleWithSAMLResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&STSClient::AssumeRoleWithSAML, request, handler, context);
        }
 
        virtual Model::AssumeRoleWithWebIdentityOutcome AssumeRoleWithWebIdentity(const Model::AssumeRoleWithWebIdentityRequest& request) const;
 
        template<typename AssumeRoleWithWebIdentityRequestT = Model::AssumeRoleWithWebIdentityRequest>
        Model::AssumeRoleWithWebIdentityOutcomeCallable AssumeRoleWithWebIdentityCallable(const AssumeRoleWithWebIdentityRequestT& request) const
        {
            return SubmitCallable(&STSClient::AssumeRoleWithWebIdentity, request);
        }
 
        template<typename AssumeRoleWithWebIdentityRequestT = Model::AssumeRoleWithWebIdentityRequest>
        void AssumeRoleWithWebIdentityAsync(const AssumeRoleWithWebIdentityRequestT& request, const AssumeRoleWithWebIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&STSClient::AssumeRoleWithWebIdentity, request, handler, context);
        }
 
        virtual Model::DecodeAuthorizationMessageOutcome DecodeAuthorizationMessage(const Model::DecodeAuthorizationMessageRequest& request) const;
 
        template<typename DecodeAuthorizationMessageRequestT = Model::DecodeAuthorizationMessageRequest>
        Model::DecodeAuthorizationMessageOutcomeCallable DecodeAuthorizationMessageCallable(const DecodeAuthorizationMessageRequestT& request) const
        {
            return SubmitCallable(&STSClient::DecodeAuthorizationMessage, request);
        }
 
        template<typename DecodeAuthorizationMessageRequestT = Model::DecodeAuthorizationMessageRequest>
        void DecodeAuthorizationMessageAsync(const DecodeAuthorizationMessageRequestT& request, const DecodeAuthorizationMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&STSClient::DecodeAuthorizationMessage, request, handler, context);
        }
 
        virtual Model::GetAccessKeyInfoOutcome GetAccessKeyInfo(const Model::GetAccessKeyInfoRequest& request) const;
 
        template<typename GetAccessKeyInfoRequestT = Model::GetAccessKeyInfoRequest>
        Model::GetAccessKeyInfoOutcomeCallable GetAccessKeyInfoCallable(const GetAccessKeyInfoRequestT& request) const
        {
            return SubmitCallable(&STSClient::GetAccessKeyInfo, request);
        }
 
        template<typename GetAccessKeyInfoRequestT = Model::GetAccessKeyInfoRequest>
        void GetAccessKeyInfoAsync(const GetAccessKeyInfoRequestT& request, const GetAccessKeyInfoResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&STSClient::GetAccessKeyInfo, request, handler, context);
        }
 
        virtual Model::GetCallerIdentityOutcome GetCallerIdentity(const Model::GetCallerIdentityRequest& request = {}) const;
 
        template<typename GetCallerIdentityRequestT = Model::GetCallerIdentityRequest>
        Model::GetCallerIdentityOutcomeCallable GetCallerIdentityCallable(const GetCallerIdentityRequestT& request = {}) const
        {
            return SubmitCallable(&STSClient::GetCallerIdentity, request);
        }
 
        template<typename GetCallerIdentityRequestT = Model::GetCallerIdentityRequest>
        void GetCallerIdentityAsync(const GetCallerIdentityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetCallerIdentityRequestT& request = {}) const
        {
            return SubmitAsync(&STSClient::GetCallerIdentity, request, handler, context);
        }
 
        virtual Model::GetFederationTokenOutcome GetFederationToken(const Model::GetFederationTokenRequest& request) const;
 
        template<typename GetFederationTokenRequestT = Model::GetFederationTokenRequest>
        Model::GetFederationTokenOutcomeCallable GetFederationTokenCallable(const GetFederationTokenRequestT& request) const
        {
            return SubmitCallable(&STSClient::GetFederationToken, request);
        }
 
        template<typename GetFederationTokenRequestT = Model::GetFederationTokenRequest>
        void GetFederationTokenAsync(const GetFederationTokenRequestT& request, const GetFederationTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&STSClient::GetFederationToken, request, handler, context);
        }
 
        virtual Model::GetSessionTokenOutcome GetSessionToken(const Model::GetSessionTokenRequest& request = {}) const;
 
        template<typename GetSessionTokenRequestT = Model::GetSessionTokenRequest>
        Model::GetSessionTokenOutcomeCallable GetSessionTokenCallable(const GetSessionTokenRequestT& request = {}) const
        {
            return SubmitCallable(&STSClient::GetSessionToken, request);
        }
 
        template<typename GetSessionTokenRequestT = Model::GetSessionTokenRequest>
        void GetSessionTokenAsync(const GetSessionTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSessionTokenRequestT& request = {}) const
        {
            return SubmitAsync(&STSClient::GetSessionToken, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<STSEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<STSClient>;
        void init(const STSClientConfiguration& clientConfiguration);
 
        STSClientConfiguration m_clientConfiguration;
        std::shared_ptr<STSEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace STS
} // namespace Aws