SSOClient.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/sso/SSOPaginationBase.h>
#include <aws/sso/SSOServiceClientModel.h>
#include <aws/sso/SSO_EXPORTS.h>
 
namespace Aws {
namespace SSO {
class AWS_SSO_API SSOClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<SSOClient>,
                              public SSOPaginationBase<SSOClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef SSOClientConfiguration ClientConfigurationType;
  typedef SSOEndpointProvider EndpointProviderType;
 
  SSOClient(const Aws::SSO::SSOClientConfiguration& clientConfiguration = Aws::SSO::SSOClientConfiguration(),
            std::shared_ptr<SSOEndpointProviderBase> endpointProvider = nullptr);
 
  SSOClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<SSOEndpointProviderBase> endpointProvider = nullptr,
            const Aws::SSO::SSOClientConfiguration& clientConfiguration = Aws::SSO::SSOClientConfiguration());
 
  SSOClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            std::shared_ptr<SSOEndpointProviderBase> endpointProvider = nullptr,
            const Aws::SSO::SSOClientConfiguration& clientConfiguration = Aws::SSO::SSOClientConfiguration());
 
  /* Legacy constructors due deprecation */
  SSOClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SSOClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  SSOClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~SSOClient();
 
  virtual Model::GetRoleCredentialsOutcome GetRoleCredentials(const Model::GetRoleCredentialsRequest& request) const;
 
  template <typename GetRoleCredentialsRequestT = Model::GetRoleCredentialsRequest>
  Model::GetRoleCredentialsOutcomeCallable GetRoleCredentialsCallable(const GetRoleCredentialsRequestT& request) const {
    return SubmitCallable(&SSOClient::GetRoleCredentials, request);
  }
 
  template <typename GetRoleCredentialsRequestT = Model::GetRoleCredentialsRequest>
  void GetRoleCredentialsAsync(const GetRoleCredentialsRequestT& request, const GetRoleCredentialsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOClient::GetRoleCredentials, request, handler, context);
  }
 
  virtual Model::ListAccountRolesOutcome ListAccountRoles(const Model::ListAccountRolesRequest& request) const;
 
  template <typename ListAccountRolesRequestT = Model::ListAccountRolesRequest>
  Model::ListAccountRolesOutcomeCallable ListAccountRolesCallable(const ListAccountRolesRequestT& request) const {
    return SubmitCallable(&SSOClient::ListAccountRoles, request);
  }
 
  template <typename ListAccountRolesRequestT = Model::ListAccountRolesRequest>
  void ListAccountRolesAsync(const ListAccountRolesRequestT& request, const ListAccountRolesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOClient::ListAccountRoles, request, handler, context);
  }
 
  virtual Model::ListAccountsOutcome ListAccounts(const Model::ListAccountsRequest& request) const;
 
  template <typename ListAccountsRequestT = Model::ListAccountsRequest>
  Model::ListAccountsOutcomeCallable ListAccountsCallable(const ListAccountsRequestT& request) const {
    return SubmitCallable(&SSOClient::ListAccounts, request);
  }
 
  template <typename ListAccountsRequestT = Model::ListAccountsRequest>
  void ListAccountsAsync(const ListAccountsRequestT& request, const ListAccountsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOClient::ListAccounts, request, handler, context);
  }
 
  virtual Model::LogoutOutcome Logout(const Model::LogoutRequest& request) const;
 
  template <typename LogoutRequestT = Model::LogoutRequest>
  Model::LogoutOutcomeCallable LogoutCallable(const LogoutRequestT& request) const {
    return SubmitCallable(&SSOClient::Logout, request);
  }
 
  template <typename LogoutRequestT = Model::LogoutRequest>
  void LogoutAsync(const LogoutRequestT& request, const LogoutResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&SSOClient::Logout, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<SSOEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<SSOClient>;
  void init(const SSOClientConfiguration& clientConfiguration);
 
  SSOClientConfiguration m_clientConfiguration;
  std::shared_ptr<SSOEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace SSO
}  // namespace Aws