Route53ProfilesClient.h

 
#pragma once
#include <aws/route53profiles/Route53Profiles_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/route53profiles/Route53ProfilesServiceClientModel.h>
 
namespace Aws
{
namespace Route53Profiles
{
  class AWS_ROUTE53PROFILES_API Route53ProfilesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<Route53ProfilesClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef Route53ProfilesClientConfiguration ClientConfigurationType;
      typedef Route53ProfilesEndpointProvider EndpointProviderType;
 
        Route53ProfilesClient(const Aws::Route53Profiles::Route53ProfilesClientConfiguration& clientConfiguration = Aws::Route53Profiles::Route53ProfilesClientConfiguration(),
                              std::shared_ptr<Route53ProfilesEndpointProviderBase> endpointProvider = nullptr);
 
        Route53ProfilesClient(const Aws::Auth::AWSCredentials& credentials,
                              std::shared_ptr<Route53ProfilesEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::Route53Profiles::Route53ProfilesClientConfiguration& clientConfiguration = Aws::Route53Profiles::Route53ProfilesClientConfiguration());
 
        Route53ProfilesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              std::shared_ptr<Route53ProfilesEndpointProviderBase> endpointProvider = nullptr,
                              const Aws::Route53Profiles::Route53ProfilesClientConfiguration& clientConfiguration = Aws::Route53Profiles::Route53ProfilesClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        Route53ProfilesClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        Route53ProfilesClient(const Aws::Auth::AWSCredentials& credentials,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        Route53ProfilesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~Route53ProfilesClient();
 
        virtual Model::AssociateProfileOutcome AssociateProfile(const Model::AssociateProfileRequest& request) const;
 
        template<typename AssociateProfileRequestT = Model::AssociateProfileRequest>
        Model::AssociateProfileOutcomeCallable AssociateProfileCallable(const AssociateProfileRequestT& request) const
        {
            return SubmitCallable(&Route53ProfilesClient::AssociateProfile, request);
        }
 
        template<typename AssociateProfileRequestT = Model::AssociateProfileRequest>
        void AssociateProfileAsync(const AssociateProfileRequestT& request, const AssociateProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53ProfilesClient::AssociateProfile, request, handler, context);
        }
 
        virtual Model::AssociateResourceToProfileOutcome AssociateResourceToProfile(const Model::AssociateResourceToProfileRequest& request) const;
 
        template<typename AssociateResourceToProfileRequestT = Model::AssociateResourceToProfileRequest>
        Model::AssociateResourceToProfileOutcomeCallable AssociateResourceToProfileCallable(const AssociateResourceToProfileRequestT& request) const
        {
            return SubmitCallable(&Route53ProfilesClient::AssociateResourceToProfile, request);
        }
 
        template<typename AssociateResourceToProfileRequestT = Model::AssociateResourceToProfileRequest>
        void AssociateResourceToProfileAsync(const AssociateResourceToProfileRequestT& request, const AssociateResourceToProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53ProfilesClient::AssociateResourceToProfile, request, handler, context);
        }
 
        virtual Model::CreateProfileOutcome CreateProfile(const Model::CreateProfileRequest& request) const;
 
        template<typename CreateProfileRequestT = Model::CreateProfileRequest>
        Model::CreateProfileOutcomeCallable CreateProfileCallable(const CreateProfileRequestT& request) const
        {
            return SubmitCallable(&Route53ProfilesClient::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(&Route53ProfilesClient::CreateProfile, 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(&Route53ProfilesClient::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(&Route53ProfilesClient::DeleteProfile, request, handler, context);
        }
 
        virtual Model::DisassociateProfileOutcome DisassociateProfile(const Model::DisassociateProfileRequest& request) const;
 
        template<typename DisassociateProfileRequestT = Model::DisassociateProfileRequest>
        Model::DisassociateProfileOutcomeCallable DisassociateProfileCallable(const DisassociateProfileRequestT& request) const
        {
            return SubmitCallable(&Route53ProfilesClient::DisassociateProfile, request);
        }
 
        template<typename DisassociateProfileRequestT = Model::DisassociateProfileRequest>
        void DisassociateProfileAsync(const DisassociateProfileRequestT& request, const DisassociateProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53ProfilesClient::DisassociateProfile, request, handler, context);
        }
 
        virtual Model::DisassociateResourceFromProfileOutcome DisassociateResourceFromProfile(const Model::DisassociateResourceFromProfileRequest& request) const;
 
        template<typename DisassociateResourceFromProfileRequestT = Model::DisassociateResourceFromProfileRequest>
        Model::DisassociateResourceFromProfileOutcomeCallable DisassociateResourceFromProfileCallable(const DisassociateResourceFromProfileRequestT& request) const
        {
            return SubmitCallable(&Route53ProfilesClient::DisassociateResourceFromProfile, request);
        }
 
        template<typename DisassociateResourceFromProfileRequestT = Model::DisassociateResourceFromProfileRequest>
        void DisassociateResourceFromProfileAsync(const DisassociateResourceFromProfileRequestT& request, const DisassociateResourceFromProfileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53ProfilesClient::DisassociateResourceFromProfile, 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(&Route53ProfilesClient::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(&Route53ProfilesClient::GetProfile, request, handler, context);
        }
 
        virtual Model::GetProfileAssociationOutcome GetProfileAssociation(const Model::GetProfileAssociationRequest& request) const;
 
        template<typename GetProfileAssociationRequestT = Model::GetProfileAssociationRequest>
        Model::GetProfileAssociationOutcomeCallable GetProfileAssociationCallable(const GetProfileAssociationRequestT& request) const
        {
            return SubmitCallable(&Route53ProfilesClient::GetProfileAssociation, request);
        }
 
        template<typename GetProfileAssociationRequestT = Model::GetProfileAssociationRequest>
        void GetProfileAssociationAsync(const GetProfileAssociationRequestT& request, const GetProfileAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53ProfilesClient::GetProfileAssociation, request, handler, context);
        }
 
        virtual Model::GetProfileResourceAssociationOutcome GetProfileResourceAssociation(const Model::GetProfileResourceAssociationRequest& request) const;
 
        template<typename GetProfileResourceAssociationRequestT = Model::GetProfileResourceAssociationRequest>
        Model::GetProfileResourceAssociationOutcomeCallable GetProfileResourceAssociationCallable(const GetProfileResourceAssociationRequestT& request) const
        {
            return SubmitCallable(&Route53ProfilesClient::GetProfileResourceAssociation, request);
        }
 
        template<typename GetProfileResourceAssociationRequestT = Model::GetProfileResourceAssociationRequest>
        void GetProfileResourceAssociationAsync(const GetProfileResourceAssociationRequestT& request, const GetProfileResourceAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53ProfilesClient::GetProfileResourceAssociation, request, handler, context);
        }
 
        virtual Model::ListProfileAssociationsOutcome ListProfileAssociations(const Model::ListProfileAssociationsRequest& request = {}) const;
 
        template<typename ListProfileAssociationsRequestT = Model::ListProfileAssociationsRequest>
        Model::ListProfileAssociationsOutcomeCallable ListProfileAssociationsCallable(const ListProfileAssociationsRequestT& request = {}) const
        {
            return SubmitCallable(&Route53ProfilesClient::ListProfileAssociations, request);
        }
 
        template<typename ListProfileAssociationsRequestT = Model::ListProfileAssociationsRequest>
        void ListProfileAssociationsAsync(const ListProfileAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProfileAssociationsRequestT& request = {}) const
        {
            return SubmitAsync(&Route53ProfilesClient::ListProfileAssociations, request, handler, context);
        }
 
        virtual Model::ListProfileResourceAssociationsOutcome ListProfileResourceAssociations(const Model::ListProfileResourceAssociationsRequest& request) const;
 
        template<typename ListProfileResourceAssociationsRequestT = Model::ListProfileResourceAssociationsRequest>
        Model::ListProfileResourceAssociationsOutcomeCallable ListProfileResourceAssociationsCallable(const ListProfileResourceAssociationsRequestT& request) const
        {
            return SubmitCallable(&Route53ProfilesClient::ListProfileResourceAssociations, request);
        }
 
        template<typename ListProfileResourceAssociationsRequestT = Model::ListProfileResourceAssociationsRequest>
        void ListProfileResourceAssociationsAsync(const ListProfileResourceAssociationsRequestT& request, const ListProfileResourceAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53ProfilesClient::ListProfileResourceAssociations, 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(&Route53ProfilesClient::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(&Route53ProfilesClient::ListProfiles, 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(&Route53ProfilesClient::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(&Route53ProfilesClient::ListTagsForResource, 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(&Route53ProfilesClient::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(&Route53ProfilesClient::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(&Route53ProfilesClient::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(&Route53ProfilesClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateProfileResourceAssociationOutcome UpdateProfileResourceAssociation(const Model::UpdateProfileResourceAssociationRequest& request) const;
 
        template<typename UpdateProfileResourceAssociationRequestT = Model::UpdateProfileResourceAssociationRequest>
        Model::UpdateProfileResourceAssociationOutcomeCallable UpdateProfileResourceAssociationCallable(const UpdateProfileResourceAssociationRequestT& request) const
        {
            return SubmitCallable(&Route53ProfilesClient::UpdateProfileResourceAssociation, request);
        }
 
        template<typename UpdateProfileResourceAssociationRequestT = Model::UpdateProfileResourceAssociationRequest>
        void UpdateProfileResourceAssociationAsync(const UpdateProfileResourceAssociationRequestT& request, const UpdateProfileResourceAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&Route53ProfilesClient::UpdateProfileResourceAssociation, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<Route53ProfilesEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53ProfilesClient>;
      void init(const Route53ProfilesClientConfiguration& clientConfiguration);
 
      Route53ProfilesClientConfiguration m_clientConfiguration;
      std::shared_ptr<Route53ProfilesEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Route53Profiles
} // namespace Aws