Route53ProfilesClient.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/route53profiles/Route53ProfilesPaginationBase.h>
#include <aws/route53profiles/Route53ProfilesServiceClientModel.h>
#include <aws/route53profiles/Route53ProfilesWaiter.h>
#include <aws/route53profiles/Route53Profiles_EXPORTS.h>
 
namespace Aws {
namespace Route53Profiles {
class AWS_ROUTE53PROFILES_API Route53ProfilesClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<Route53ProfilesClient>,
                                                      public Route53ProfilesPaginationBase<Route53ProfilesClient>,
                                                      public Route53ProfilesWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<Route53ProfilesEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<Route53ProfilesClient>;
  void init(const Route53ProfilesClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, Route53ProfilesError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  Route53ProfilesClientConfiguration m_clientConfiguration;
  std::shared_ptr<Route53ProfilesEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Route53Profiles
}  // namespace Aws