RolesAnywhereClient.h

 
#pragma once
#include <aws/rolesanywhere/RolesAnywhere_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/rolesanywhere/RolesAnywhereServiceClientModel.h>
 
namespace Aws
{
namespace RolesAnywhere
{
  class AWS_ROLESANYWHERE_API RolesAnywhereClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<RolesAnywhereEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<RolesAnywhereClient>;
      void init(const RolesAnywhereClientConfiguration& clientConfiguration);
 
      RolesAnywhereClientConfiguration m_clientConfiguration;
      std::shared_ptr<RolesAnywhereEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace RolesAnywhere
} // namespace Aws