RolesAnywhereClient.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/rolesanywhere/RolesAnywherePaginationBase.h>
#include <aws/rolesanywhere/RolesAnywhereServiceClientModel.h>
#include <aws/rolesanywhere/RolesAnywhereWaiter.h>
#include <aws/rolesanywhere/RolesAnywhere_EXPORTS.h>
 
namespace Aws {
namespace RolesAnywhere {
class AWS_ROLESANYWHERE_API RolesAnywhereClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<RolesAnywhereClient>,
                                                  public RolesAnywherePaginationBase<RolesAnywhereClient>,
                                                  public RolesAnywhereWaiter<RolesAnywhereClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef RolesAnywhereClientConfiguration ClientConfigurationType;
  typedef RolesAnywhereEndpointProvider EndpointProviderType;
 
  RolesAnywhereClient(const Aws::RolesAnywhere::RolesAnywhereClientConfiguration& clientConfiguration =
                          Aws::RolesAnywhere::RolesAnywhereClientConfiguration(),
                      std::shared_ptr<RolesAnywhereEndpointProviderBase> endpointProvider = nullptr);
 
  RolesAnywhereClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<RolesAnywhereEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::RolesAnywhere::RolesAnywhereClientConfiguration& clientConfiguration =
                          Aws::RolesAnywhere::RolesAnywhereClientConfiguration());
 
  RolesAnywhereClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<RolesAnywhereEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::RolesAnywhere::RolesAnywhereClientConfiguration& clientConfiguration =
                          Aws::RolesAnywhere::RolesAnywhereClientConfiguration());
 
  /* Legacy constructors due deprecation */
  RolesAnywhereClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  RolesAnywhereClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  RolesAnywhereClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~RolesAnywhereClient();
 
  virtual Model::CreateProfileOutcome CreateProfile(const Model::CreateProfileRequest& request) const;
 
  template <typename CreateProfileRequestT = Model::CreateProfileRequest>
  Model::CreateProfileOutcomeCallable CreateProfileCallable(const CreateProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::CreateProfile, request);
  }
 
  template <typename CreateProfileRequestT = Model::CreateProfileRequest>
  void CreateProfileAsync(const CreateProfileRequestT& request, const CreateProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::CreateProfile, request, handler, context);
  }
 
  virtual Model::CreateTrustAnchorOutcome CreateTrustAnchor(const Model::CreateTrustAnchorRequest& request) const;
 
  template <typename CreateTrustAnchorRequestT = Model::CreateTrustAnchorRequest>
  Model::CreateTrustAnchorOutcomeCallable CreateTrustAnchorCallable(const CreateTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::CreateTrustAnchor, request);
  }
 
  template <typename CreateTrustAnchorRequestT = Model::CreateTrustAnchorRequest>
  void CreateTrustAnchorAsync(const CreateTrustAnchorRequestT& request, const CreateTrustAnchorResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::CreateTrustAnchor, request, handler, context);
  }
 
  virtual Model::DeleteAttributeMappingOutcome DeleteAttributeMapping(const Model::DeleteAttributeMappingRequest& request) const;
 
  template <typename DeleteAttributeMappingRequestT = Model::DeleteAttributeMappingRequest>
  Model::DeleteAttributeMappingOutcomeCallable DeleteAttributeMappingCallable(const DeleteAttributeMappingRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DeleteAttributeMapping, request);
  }
 
  template <typename DeleteAttributeMappingRequestT = Model::DeleteAttributeMappingRequest>
  void DeleteAttributeMappingAsync(const DeleteAttributeMappingRequestT& request,
                                   const DeleteAttributeMappingResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DeleteAttributeMapping, request, handler, context);
  }
 
  virtual Model::DeleteCrlOutcome DeleteCrl(const Model::DeleteCrlRequest& request) const;
 
  template <typename DeleteCrlRequestT = Model::DeleteCrlRequest>
  Model::DeleteCrlOutcomeCallable DeleteCrlCallable(const DeleteCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DeleteCrl, request);
  }
 
  template <typename DeleteCrlRequestT = Model::DeleteCrlRequest>
  void DeleteCrlAsync(const DeleteCrlRequestT& request, const DeleteCrlResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DeleteCrl, request, handler, context);
  }
 
  virtual Model::DeleteProfileOutcome DeleteProfile(const Model::DeleteProfileRequest& request) const;
 
  template <typename DeleteProfileRequestT = Model::DeleteProfileRequest>
  Model::DeleteProfileOutcomeCallable DeleteProfileCallable(const DeleteProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DeleteProfile, request);
  }
 
  template <typename DeleteProfileRequestT = Model::DeleteProfileRequest>
  void DeleteProfileAsync(const DeleteProfileRequestT& request, const DeleteProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DeleteProfile, request, handler, context);
  }
 
  virtual Model::DeleteTrustAnchorOutcome DeleteTrustAnchor(const Model::DeleteTrustAnchorRequest& request) const;
 
  template <typename DeleteTrustAnchorRequestT = Model::DeleteTrustAnchorRequest>
  Model::DeleteTrustAnchorOutcomeCallable DeleteTrustAnchorCallable(const DeleteTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DeleteTrustAnchor, request);
  }
 
  template <typename DeleteTrustAnchorRequestT = Model::DeleteTrustAnchorRequest>
  void DeleteTrustAnchorAsync(const DeleteTrustAnchorRequestT& request, const DeleteTrustAnchorResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DeleteTrustAnchor, request, handler, context);
  }
 
  virtual Model::DisableCrlOutcome DisableCrl(const Model::DisableCrlRequest& request) const;
 
  template <typename DisableCrlRequestT = Model::DisableCrlRequest>
  Model::DisableCrlOutcomeCallable DisableCrlCallable(const DisableCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DisableCrl, request);
  }
 
  template <typename DisableCrlRequestT = Model::DisableCrlRequest>
  void DisableCrlAsync(const DisableCrlRequestT& request, const DisableCrlResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DisableCrl, request, handler, context);
  }
 
  virtual Model::DisableProfileOutcome DisableProfile(const Model::DisableProfileRequest& request) const;
 
  template <typename DisableProfileRequestT = Model::DisableProfileRequest>
  Model::DisableProfileOutcomeCallable DisableProfileCallable(const DisableProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DisableProfile, request);
  }
 
  template <typename DisableProfileRequestT = Model::DisableProfileRequest>
  void DisableProfileAsync(const DisableProfileRequestT& request, const DisableProfileResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DisableProfile, request, handler, context);
  }
 
  virtual Model::DisableTrustAnchorOutcome DisableTrustAnchor(const Model::DisableTrustAnchorRequest& request) const;
 
  template <typename DisableTrustAnchorRequestT = Model::DisableTrustAnchorRequest>
  Model::DisableTrustAnchorOutcomeCallable DisableTrustAnchorCallable(const DisableTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::DisableTrustAnchor, request);
  }
 
  template <typename DisableTrustAnchorRequestT = Model::DisableTrustAnchorRequest>
  void DisableTrustAnchorAsync(const DisableTrustAnchorRequestT& request, const DisableTrustAnchorResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::DisableTrustAnchor, request, handler, context);
  }
 
  virtual Model::EnableCrlOutcome EnableCrl(const Model::EnableCrlRequest& request) const;
 
  template <typename EnableCrlRequestT = Model::EnableCrlRequest>
  Model::EnableCrlOutcomeCallable EnableCrlCallable(const EnableCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::EnableCrl, request);
  }
 
  template <typename EnableCrlRequestT = Model::EnableCrlRequest>
  void EnableCrlAsync(const EnableCrlRequestT& request, const EnableCrlResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::EnableCrl, request, handler, context);
  }
 
  virtual Model::EnableProfileOutcome EnableProfile(const Model::EnableProfileRequest& request) const;
 
  template <typename EnableProfileRequestT = Model::EnableProfileRequest>
  Model::EnableProfileOutcomeCallable EnableProfileCallable(const EnableProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::EnableProfile, request);
  }
 
  template <typename EnableProfileRequestT = Model::EnableProfileRequest>
  void EnableProfileAsync(const EnableProfileRequestT& request, const EnableProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::EnableProfile, request, handler, context);
  }
 
  virtual Model::EnableTrustAnchorOutcome EnableTrustAnchor(const Model::EnableTrustAnchorRequest& request) const;
 
  template <typename EnableTrustAnchorRequestT = Model::EnableTrustAnchorRequest>
  Model::EnableTrustAnchorOutcomeCallable EnableTrustAnchorCallable(const EnableTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::EnableTrustAnchor, request);
  }
 
  template <typename EnableTrustAnchorRequestT = Model::EnableTrustAnchorRequest>
  void EnableTrustAnchorAsync(const EnableTrustAnchorRequestT& request, const EnableTrustAnchorResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::EnableTrustAnchor, request, handler, context);
  }
 
  virtual Model::GetCrlOutcome GetCrl(const Model::GetCrlRequest& request) const;
 
  template <typename GetCrlRequestT = Model::GetCrlRequest>
  Model::GetCrlOutcomeCallable GetCrlCallable(const GetCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::GetCrl, request);
  }
 
  template <typename GetCrlRequestT = Model::GetCrlRequest>
  void GetCrlAsync(const GetCrlRequestT& request, const GetCrlResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::GetCrl, request, handler, context);
  }
 
  virtual Model::GetProfileOutcome GetProfile(const Model::GetProfileRequest& request) const;
 
  template <typename GetProfileRequestT = Model::GetProfileRequest>
  Model::GetProfileOutcomeCallable GetProfileCallable(const GetProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::GetProfile, request);
  }
 
  template <typename GetProfileRequestT = Model::GetProfileRequest>
  void GetProfileAsync(const GetProfileRequestT& request, const GetProfileResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::GetProfile, request, handler, context);
  }
 
  virtual Model::GetSubjectOutcome GetSubject(const Model::GetSubjectRequest& request) const;
 
  template <typename GetSubjectRequestT = Model::GetSubjectRequest>
  Model::GetSubjectOutcomeCallable GetSubjectCallable(const GetSubjectRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::GetSubject, request);
  }
 
  template <typename GetSubjectRequestT = Model::GetSubjectRequest>
  void GetSubjectAsync(const GetSubjectRequestT& request, const GetSubjectResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::GetSubject, request, handler, context);
  }
 
  virtual Model::GetTrustAnchorOutcome GetTrustAnchor(const Model::GetTrustAnchorRequest& request) const;
 
  template <typename GetTrustAnchorRequestT = Model::GetTrustAnchorRequest>
  Model::GetTrustAnchorOutcomeCallable GetTrustAnchorCallable(const GetTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::GetTrustAnchor, request);
  }
 
  template <typename GetTrustAnchorRequestT = Model::GetTrustAnchorRequest>
  void GetTrustAnchorAsync(const GetTrustAnchorRequestT& request, const GetTrustAnchorResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::GetTrustAnchor, request, handler, context);
  }
 
  virtual Model::ImportCrlOutcome ImportCrl(const Model::ImportCrlRequest& request) const;
 
  template <typename ImportCrlRequestT = Model::ImportCrlRequest>
  Model::ImportCrlOutcomeCallable ImportCrlCallable(const ImportCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::ImportCrl, request);
  }
 
  template <typename ImportCrlRequestT = Model::ImportCrlRequest>
  void ImportCrlAsync(const ImportCrlRequestT& request, const ImportCrlResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::ImportCrl, request, handler, context);
  }
 
  virtual Model::ListCrlsOutcome ListCrls(const Model::ListCrlsRequest& request = {}) const;
 
  template <typename ListCrlsRequestT = Model::ListCrlsRequest>
  Model::ListCrlsOutcomeCallable ListCrlsCallable(const ListCrlsRequestT& request = {}) const {
    return SubmitCallable(&RolesAnywhereClient::ListCrls, request);
  }
 
  template <typename ListCrlsRequestT = Model::ListCrlsRequest>
  void ListCrlsAsync(const ListCrlsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const ListCrlsRequestT& request = {}) const {
    return SubmitAsync(&RolesAnywhereClient::ListCrls, request, handler, context);
  }
 
  virtual Model::ListProfilesOutcome ListProfiles(const Model::ListProfilesRequest& request = {}) const;
 
  template <typename ListProfilesRequestT = Model::ListProfilesRequest>
  Model::ListProfilesOutcomeCallable ListProfilesCallable(const ListProfilesRequestT& request = {}) const {
    return SubmitCallable(&RolesAnywhereClient::ListProfiles, request);
  }
 
  template <typename ListProfilesRequestT = Model::ListProfilesRequest>
  void ListProfilesAsync(const ListProfilesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListProfilesRequestT& request = {}) const {
    return SubmitAsync(&RolesAnywhereClient::ListProfiles, request, handler, context);
  }
 
  virtual Model::ListSubjectsOutcome ListSubjects(const Model::ListSubjectsRequest& request = {}) const;
 
  template <typename ListSubjectsRequestT = Model::ListSubjectsRequest>
  Model::ListSubjectsOutcomeCallable ListSubjectsCallable(const ListSubjectsRequestT& request = {}) const {
    return SubmitCallable(&RolesAnywhereClient::ListSubjects, request);
  }
 
  template <typename ListSubjectsRequestT = Model::ListSubjectsRequest>
  void ListSubjectsAsync(const ListSubjectsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListSubjectsRequestT& request = {}) const {
    return SubmitAsync(&RolesAnywhereClient::ListSubjects, 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(&RolesAnywhereClient::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(&RolesAnywhereClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTrustAnchorsOutcome ListTrustAnchors(const Model::ListTrustAnchorsRequest& request = {}) const;
 
  template <typename ListTrustAnchorsRequestT = Model::ListTrustAnchorsRequest>
  Model::ListTrustAnchorsOutcomeCallable ListTrustAnchorsCallable(const ListTrustAnchorsRequestT& request = {}) const {
    return SubmitCallable(&RolesAnywhereClient::ListTrustAnchors, request);
  }
 
  template <typename ListTrustAnchorsRequestT = Model::ListTrustAnchorsRequest>
  void ListTrustAnchorsAsync(const ListTrustAnchorsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListTrustAnchorsRequestT& request = {}) const {
    return SubmitAsync(&RolesAnywhereClient::ListTrustAnchors, request, handler, context);
  }
 
  virtual Model::PutAttributeMappingOutcome PutAttributeMapping(const Model::PutAttributeMappingRequest& request) const;
 
  template <typename PutAttributeMappingRequestT = Model::PutAttributeMappingRequest>
  Model::PutAttributeMappingOutcomeCallable PutAttributeMappingCallable(const PutAttributeMappingRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::PutAttributeMapping, request);
  }
 
  template <typename PutAttributeMappingRequestT = Model::PutAttributeMappingRequest>
  void PutAttributeMappingAsync(const PutAttributeMappingRequestT& request, const PutAttributeMappingResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::PutAttributeMapping, request, handler, context);
  }
 
  virtual Model::PutNotificationSettingsOutcome PutNotificationSettings(const Model::PutNotificationSettingsRequest& request) const;
 
  template <typename PutNotificationSettingsRequestT = Model::PutNotificationSettingsRequest>
  Model::PutNotificationSettingsOutcomeCallable PutNotificationSettingsCallable(const PutNotificationSettingsRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::PutNotificationSettings, request);
  }
 
  template <typename PutNotificationSettingsRequestT = Model::PutNotificationSettingsRequest>
  void PutNotificationSettingsAsync(const PutNotificationSettingsRequestT& request,
                                    const PutNotificationSettingsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::PutNotificationSettings, request, handler, context);
  }
 
  virtual Model::ResetNotificationSettingsOutcome ResetNotificationSettings(const Model::ResetNotificationSettingsRequest& request) const;
 
  template <typename ResetNotificationSettingsRequestT = Model::ResetNotificationSettingsRequest>
  Model::ResetNotificationSettingsOutcomeCallable ResetNotificationSettingsCallable(
      const ResetNotificationSettingsRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::ResetNotificationSettings, request);
  }
 
  template <typename ResetNotificationSettingsRequestT = Model::ResetNotificationSettingsRequest>
  void ResetNotificationSettingsAsync(const ResetNotificationSettingsRequestT& request,
                                      const ResetNotificationSettingsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::ResetNotificationSettings, 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(&RolesAnywhereClient::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(&RolesAnywhereClient::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(&RolesAnywhereClient::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(&RolesAnywhereClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateCrlOutcome UpdateCrl(const Model::UpdateCrlRequest& request) const;
 
  template <typename UpdateCrlRequestT = Model::UpdateCrlRequest>
  Model::UpdateCrlOutcomeCallable UpdateCrlCallable(const UpdateCrlRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::UpdateCrl, request);
  }
 
  template <typename UpdateCrlRequestT = Model::UpdateCrlRequest>
  void UpdateCrlAsync(const UpdateCrlRequestT& request, const UpdateCrlResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::UpdateCrl, request, handler, context);
  }
 
  virtual Model::UpdateProfileOutcome UpdateProfile(const Model::UpdateProfileRequest& request) const;
 
  template <typename UpdateProfileRequestT = Model::UpdateProfileRequest>
  Model::UpdateProfileOutcomeCallable UpdateProfileCallable(const UpdateProfileRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::UpdateProfile, request);
  }
 
  template <typename UpdateProfileRequestT = Model::UpdateProfileRequest>
  void UpdateProfileAsync(const UpdateProfileRequestT& request, const UpdateProfileResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::UpdateProfile, request, handler, context);
  }
 
  virtual Model::UpdateTrustAnchorOutcome UpdateTrustAnchor(const Model::UpdateTrustAnchorRequest& request) const;
 
  template <typename UpdateTrustAnchorRequestT = Model::UpdateTrustAnchorRequest>
  Model::UpdateTrustAnchorOutcomeCallable UpdateTrustAnchorCallable(const UpdateTrustAnchorRequestT& request) const {
    return SubmitCallable(&RolesAnywhereClient::UpdateTrustAnchor, request);
  }
 
  template <typename UpdateTrustAnchorRequestT = Model::UpdateTrustAnchorRequest>
  void UpdateTrustAnchorAsync(const UpdateTrustAnchorRequestT& request, const UpdateTrustAnchorResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&RolesAnywhereClient::UpdateTrustAnchor, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<RolesAnywhereEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<RolesAnywhereClient>;
  void init(const RolesAnywhereClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, RolesAnywhereError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  RolesAnywhereClientConfiguration m_clientConfiguration;
  std::shared_ptr<RolesAnywhereEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace RolesAnywhere
}  // namespace Aws