STSClient.h

 
#pragma once
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/sts/STSServiceClientModel.h>
#include <aws/sts/STS_EXPORTS.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::AssumeRootOutcome AssumeRoot(const Model::AssumeRootRequest& request) const;
 
  template <typename AssumeRootRequestT = Model::AssumeRootRequest>
  Model::AssumeRootOutcomeCallable AssumeRootCallable(const AssumeRootRequestT& request) const {
    return SubmitCallable(&STSClient::AssumeRoot, request);
  }
 
  template <typename AssumeRootRequestT = Model::AssumeRootRequest>
  void AssumeRootAsync(const AssumeRootRequestT& request, const AssumeRootResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&STSClient::AssumeRoot, 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