STSClient.h

 
#pragma once
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/sts/STSErrorMarshaller.h>
#include <aws/sts/STSPaginationBase.h>
#include <aws/sts/STSServiceClientModel.h>
#include <aws/sts/STSWaiter.h>
#include <aws/sts/STS_EXPORTS.h>
#include <smithy/client/AwsSmithyClient.h>
#include <smithy/client/serializer/XmlOutcomeSerializer.h>
#include <smithy/identity/auth/built-in/GenericAuthSchemeResolver.h>
#include <smithy/identity/auth/built-in/NoAuthScheme.h>
#include <smithy/identity/auth/built-in/SigV4AuthScheme.h>
#include <smithy/identity/auth/built-in/SigV4aAuthScheme.h>
 
namespace Aws {
namespace STS {
AWS_STS_API extern const char SERVICE_NAME[];
class AWS_STS_API STSClient
    : Aws::Client::ClientWithAsyncTemplateMethods<STSClient>,
      public smithy::client::AwsSmithyClientT<Aws::STS::SERVICE_NAME, Aws::STS::STSClientConfiguration, smithy::AuthSchemeResolverBase<>,
                                              Aws::Crt::Variant<smithy::SigV4AuthScheme, smithy::SigV4aAuthScheme, smithy::NoAuthScheme>,
                                              STSEndpointProviderBase, smithy::client::XmlOutcomeSerializer, smithy::client::XmlOutcome,
                                              Aws::Client::STSErrorMarshaller>,
      public STSPaginationBase<STSClient>,
      public STSWaiter<STSClient> {
 public:
  static const char* GetServiceName();
  static const char* GetAllocationTag();
  inline const char* GetServiceClientName() const override { return "STS"; }
 
  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();
 
  virtual 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::GetDelegatedAccessTokenOutcome GetDelegatedAccessToken(const Model::GetDelegatedAccessTokenRequest& request) const;
 
  template <typename GetDelegatedAccessTokenRequestT = Model::GetDelegatedAccessTokenRequest>
  Model::GetDelegatedAccessTokenOutcomeCallable GetDelegatedAccessTokenCallable(const GetDelegatedAccessTokenRequestT& request) const {
    return SubmitCallable(&STSClient::GetDelegatedAccessToken, request);
  }
 
  template <typename GetDelegatedAccessTokenRequestT = Model::GetDelegatedAccessTokenRequest>
  void GetDelegatedAccessTokenAsync(const GetDelegatedAccessTokenRequestT& request,
                                    const GetDelegatedAccessTokenResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&STSClient::GetDelegatedAccessToken, 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);
  }
 
  virtual Model::GetWebIdentityTokenOutcome GetWebIdentityToken(const Model::GetWebIdentityTokenRequest& request) const;
 
  template <typename GetWebIdentityTokenRequestT = Model::GetWebIdentityTokenRequest>
  Model::GetWebIdentityTokenOutcomeCallable GetWebIdentityTokenCallable(const GetWebIdentityTokenRequestT& request) const {
    return SubmitCallable(&STSClient::GetWebIdentityToken, request);
  }
 
  template <typename GetWebIdentityTokenRequestT = Model::GetWebIdentityTokenRequest>
  void GetWebIdentityTokenAsync(const GetWebIdentityTokenRequestT& request, const GetWebIdentityTokenResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&STSClient::GetWebIdentityToken, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<STSEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<STSClient>;
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>, STSError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
};
 
}  // namespace STS
}  // namespace Aws