ServiceDiscoveryClient.h

 
#pragma once
#include <aws/servicediscovery/ServiceDiscovery_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/servicediscovery/ServiceDiscoveryServiceClientModel.h>
 
namespace Aws
{
namespace ServiceDiscovery
{
  class AWS_SERVICEDISCOVERY_API ServiceDiscoveryClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ServiceDiscoveryClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ServiceDiscoveryClientConfiguration ClientConfigurationType;
      typedef ServiceDiscoveryEndpointProvider EndpointProviderType;
 
        ServiceDiscoveryClient(const Aws::ServiceDiscovery::ServiceDiscoveryClientConfiguration& clientConfiguration = Aws::ServiceDiscovery::ServiceDiscoveryClientConfiguration(),
                               std::shared_ptr<ServiceDiscoveryEndpointProviderBase> endpointProvider = nullptr);
 
        ServiceDiscoveryClient(const Aws::Auth::AWSCredentials& credentials,
                               std::shared_ptr<ServiceDiscoveryEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::ServiceDiscovery::ServiceDiscoveryClientConfiguration& clientConfiguration = Aws::ServiceDiscovery::ServiceDiscoveryClientConfiguration());
 
        ServiceDiscoveryClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               std::shared_ptr<ServiceDiscoveryEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::ServiceDiscovery::ServiceDiscoveryClientConfiguration& clientConfiguration = Aws::ServiceDiscovery::ServiceDiscoveryClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ServiceDiscoveryClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ServiceDiscoveryClient(const Aws::Auth::AWSCredentials& credentials,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ServiceDiscoveryClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ServiceDiscoveryClient();
 
        virtual Model::CreateHttpNamespaceOutcome CreateHttpNamespace(const Model::CreateHttpNamespaceRequest& request) const;
 
        template<typename CreateHttpNamespaceRequestT = Model::CreateHttpNamespaceRequest>
        Model::CreateHttpNamespaceOutcomeCallable CreateHttpNamespaceCallable(const CreateHttpNamespaceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::CreateHttpNamespace, request);
        }
 
        template<typename CreateHttpNamespaceRequestT = Model::CreateHttpNamespaceRequest>
        void CreateHttpNamespaceAsync(const CreateHttpNamespaceRequestT& request, const CreateHttpNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::CreateHttpNamespace, request, handler, context);
        }
 
        virtual Model::CreatePrivateDnsNamespaceOutcome CreatePrivateDnsNamespace(const Model::CreatePrivateDnsNamespaceRequest& request) const;
 
        template<typename CreatePrivateDnsNamespaceRequestT = Model::CreatePrivateDnsNamespaceRequest>
        Model::CreatePrivateDnsNamespaceOutcomeCallable CreatePrivateDnsNamespaceCallable(const CreatePrivateDnsNamespaceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::CreatePrivateDnsNamespace, request);
        }
 
        template<typename CreatePrivateDnsNamespaceRequestT = Model::CreatePrivateDnsNamespaceRequest>
        void CreatePrivateDnsNamespaceAsync(const CreatePrivateDnsNamespaceRequestT& request, const CreatePrivateDnsNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::CreatePrivateDnsNamespace, request, handler, context);
        }
 
        virtual Model::CreatePublicDnsNamespaceOutcome CreatePublicDnsNamespace(const Model::CreatePublicDnsNamespaceRequest& request) const;
 
        template<typename CreatePublicDnsNamespaceRequestT = Model::CreatePublicDnsNamespaceRequest>
        Model::CreatePublicDnsNamespaceOutcomeCallable CreatePublicDnsNamespaceCallable(const CreatePublicDnsNamespaceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::CreatePublicDnsNamespace, request);
        }
 
        template<typename CreatePublicDnsNamespaceRequestT = Model::CreatePublicDnsNamespaceRequest>
        void CreatePublicDnsNamespaceAsync(const CreatePublicDnsNamespaceRequestT& request, const CreatePublicDnsNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::CreatePublicDnsNamespace, request, handler, context);
        }
 
        virtual Model::CreateServiceOutcome CreateService(const Model::CreateServiceRequest& request) const;
 
        template<typename CreateServiceRequestT = Model::CreateServiceRequest>
        Model::CreateServiceOutcomeCallable CreateServiceCallable(const CreateServiceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::CreateService, request);
        }
 
        template<typename CreateServiceRequestT = Model::CreateServiceRequest>
        void CreateServiceAsync(const CreateServiceRequestT& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::CreateService, request, handler, context);
        }
 
        virtual Model::DeleteNamespaceOutcome DeleteNamespace(const Model::DeleteNamespaceRequest& request) const;
 
        template<typename DeleteNamespaceRequestT = Model::DeleteNamespaceRequest>
        Model::DeleteNamespaceOutcomeCallable DeleteNamespaceCallable(const DeleteNamespaceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::DeleteNamespace, request);
        }
 
        template<typename DeleteNamespaceRequestT = Model::DeleteNamespaceRequest>
        void DeleteNamespaceAsync(const DeleteNamespaceRequestT& request, const DeleteNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::DeleteNamespace, request, handler, context);
        }
 
        virtual Model::DeleteServiceOutcome DeleteService(const Model::DeleteServiceRequest& request) const;
 
        template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
        Model::DeleteServiceOutcomeCallable DeleteServiceCallable(const DeleteServiceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::DeleteService, request);
        }
 
        template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
        void DeleteServiceAsync(const DeleteServiceRequestT& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::DeleteService, request, handler, context);
        }
 
        virtual Model::DeleteServiceAttributesOutcome DeleteServiceAttributes(const Model::DeleteServiceAttributesRequest& request) const;
 
        template<typename DeleteServiceAttributesRequestT = Model::DeleteServiceAttributesRequest>
        Model::DeleteServiceAttributesOutcomeCallable DeleteServiceAttributesCallable(const DeleteServiceAttributesRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::DeleteServiceAttributes, request);
        }
 
        template<typename DeleteServiceAttributesRequestT = Model::DeleteServiceAttributesRequest>
        void DeleteServiceAttributesAsync(const DeleteServiceAttributesRequestT& request, const DeleteServiceAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::DeleteServiceAttributes, request, handler, context);
        }
 
        virtual Model::DeregisterInstanceOutcome DeregisterInstance(const Model::DeregisterInstanceRequest& request) const;
 
        template<typename DeregisterInstanceRequestT = Model::DeregisterInstanceRequest>
        Model::DeregisterInstanceOutcomeCallable DeregisterInstanceCallable(const DeregisterInstanceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::DeregisterInstance, request);
        }
 
        template<typename DeregisterInstanceRequestT = Model::DeregisterInstanceRequest>
        void DeregisterInstanceAsync(const DeregisterInstanceRequestT& request, const DeregisterInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::DeregisterInstance, request, handler, context);
        }
 
        virtual Model::DiscoverInstancesOutcome DiscoverInstances(const Model::DiscoverInstancesRequest& request) const;
 
        template<typename DiscoverInstancesRequestT = Model::DiscoverInstancesRequest>
        Model::DiscoverInstancesOutcomeCallable DiscoverInstancesCallable(const DiscoverInstancesRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::DiscoverInstances, request);
        }
 
        template<typename DiscoverInstancesRequestT = Model::DiscoverInstancesRequest>
        void DiscoverInstancesAsync(const DiscoverInstancesRequestT& request, const DiscoverInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::DiscoverInstances, request, handler, context);
        }
 
        virtual Model::DiscoverInstancesRevisionOutcome DiscoverInstancesRevision(const Model::DiscoverInstancesRevisionRequest& request) const;
 
        template<typename DiscoverInstancesRevisionRequestT = Model::DiscoverInstancesRevisionRequest>
        Model::DiscoverInstancesRevisionOutcomeCallable DiscoverInstancesRevisionCallable(const DiscoverInstancesRevisionRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::DiscoverInstancesRevision, request);
        }
 
        template<typename DiscoverInstancesRevisionRequestT = Model::DiscoverInstancesRevisionRequest>
        void DiscoverInstancesRevisionAsync(const DiscoverInstancesRevisionRequestT& request, const DiscoverInstancesRevisionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::DiscoverInstancesRevision, request, handler, context);
        }
 
        virtual Model::GetInstanceOutcome GetInstance(const Model::GetInstanceRequest& request) const;
 
        template<typename GetInstanceRequestT = Model::GetInstanceRequest>
        Model::GetInstanceOutcomeCallable GetInstanceCallable(const GetInstanceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::GetInstance, request);
        }
 
        template<typename GetInstanceRequestT = Model::GetInstanceRequest>
        void GetInstanceAsync(const GetInstanceRequestT& request, const GetInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::GetInstance, request, handler, context);
        }
 
        virtual Model::GetInstancesHealthStatusOutcome GetInstancesHealthStatus(const Model::GetInstancesHealthStatusRequest& request) const;
 
        template<typename GetInstancesHealthStatusRequestT = Model::GetInstancesHealthStatusRequest>
        Model::GetInstancesHealthStatusOutcomeCallable GetInstancesHealthStatusCallable(const GetInstancesHealthStatusRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::GetInstancesHealthStatus, request);
        }
 
        template<typename GetInstancesHealthStatusRequestT = Model::GetInstancesHealthStatusRequest>
        void GetInstancesHealthStatusAsync(const GetInstancesHealthStatusRequestT& request, const GetInstancesHealthStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::GetInstancesHealthStatus, request, handler, context);
        }
 
        virtual Model::GetNamespaceOutcome GetNamespace(const Model::GetNamespaceRequest& request) const;
 
        template<typename GetNamespaceRequestT = Model::GetNamespaceRequest>
        Model::GetNamespaceOutcomeCallable GetNamespaceCallable(const GetNamespaceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::GetNamespace, request);
        }
 
        template<typename GetNamespaceRequestT = Model::GetNamespaceRequest>
        void GetNamespaceAsync(const GetNamespaceRequestT& request, const GetNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::GetNamespace, request, handler, context);
        }
 
        virtual Model::GetOperationOutcome GetOperation(const Model::GetOperationRequest& request) const;
 
        template<typename GetOperationRequestT = Model::GetOperationRequest>
        Model::GetOperationOutcomeCallable GetOperationCallable(const GetOperationRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::GetOperation, request);
        }
 
        template<typename GetOperationRequestT = Model::GetOperationRequest>
        void GetOperationAsync(const GetOperationRequestT& request, const GetOperationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::GetOperation, request, handler, context);
        }
 
        virtual Model::GetServiceOutcome GetService(const Model::GetServiceRequest& request) const;
 
        template<typename GetServiceRequestT = Model::GetServiceRequest>
        Model::GetServiceOutcomeCallable GetServiceCallable(const GetServiceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::GetService, request);
        }
 
        template<typename GetServiceRequestT = Model::GetServiceRequest>
        void GetServiceAsync(const GetServiceRequestT& request, const GetServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::GetService, request, handler, context);
        }
 
        virtual Model::GetServiceAttributesOutcome GetServiceAttributes(const Model::GetServiceAttributesRequest& request) const;
 
        template<typename GetServiceAttributesRequestT = Model::GetServiceAttributesRequest>
        Model::GetServiceAttributesOutcomeCallable GetServiceAttributesCallable(const GetServiceAttributesRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::GetServiceAttributes, request);
        }
 
        template<typename GetServiceAttributesRequestT = Model::GetServiceAttributesRequest>
        void GetServiceAttributesAsync(const GetServiceAttributesRequestT& request, const GetServiceAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::GetServiceAttributes, request, handler, context);
        }
 
        virtual Model::ListInstancesOutcome ListInstances(const Model::ListInstancesRequest& request) const;
 
        template<typename ListInstancesRequestT = Model::ListInstancesRequest>
        Model::ListInstancesOutcomeCallable ListInstancesCallable(const ListInstancesRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::ListInstances, request);
        }
 
        template<typename ListInstancesRequestT = Model::ListInstancesRequest>
        void ListInstancesAsync(const ListInstancesRequestT& request, const ListInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::ListInstances, request, handler, context);
        }
 
        virtual Model::ListNamespacesOutcome ListNamespaces(const Model::ListNamespacesRequest& request = {}) const;
 
        template<typename ListNamespacesRequestT = Model::ListNamespacesRequest>
        Model::ListNamespacesOutcomeCallable ListNamespacesCallable(const ListNamespacesRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::ListNamespaces, request);
        }
 
        template<typename ListNamespacesRequestT = Model::ListNamespacesRequest>
        void ListNamespacesAsync(const ListNamespacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListNamespacesRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::ListNamespaces, request, handler, context);
        }
 
        virtual Model::ListOperationsOutcome ListOperations(const Model::ListOperationsRequest& request = {}) const;
 
        template<typename ListOperationsRequestT = Model::ListOperationsRequest>
        Model::ListOperationsOutcomeCallable ListOperationsCallable(const ListOperationsRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::ListOperations, request);
        }
 
        template<typename ListOperationsRequestT = Model::ListOperationsRequest>
        void ListOperationsAsync(const ListOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOperationsRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::ListOperations, request, handler, context);
        }
 
        virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request = {}) const;
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        Model::ListServicesOutcomeCallable ListServicesCallable(const ListServicesRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::ListServices, request);
        }
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        void ListServicesAsync(const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServicesRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::ListServices, 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(&ServiceDiscoveryClient::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(&ServiceDiscoveryClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::RegisterInstanceOutcome RegisterInstance(const Model::RegisterInstanceRequest& request) const;
 
        template<typename RegisterInstanceRequestT = Model::RegisterInstanceRequest>
        Model::RegisterInstanceOutcomeCallable RegisterInstanceCallable(const RegisterInstanceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::RegisterInstance, request);
        }
 
        template<typename RegisterInstanceRequestT = Model::RegisterInstanceRequest>
        void RegisterInstanceAsync(const RegisterInstanceRequestT& request, const RegisterInstanceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::RegisterInstance, 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(&ServiceDiscoveryClient::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(&ServiceDiscoveryClient::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(&ServiceDiscoveryClient::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(&ServiceDiscoveryClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateHttpNamespaceOutcome UpdateHttpNamespace(const Model::UpdateHttpNamespaceRequest& request) const;
 
        template<typename UpdateHttpNamespaceRequestT = Model::UpdateHttpNamespaceRequest>
        Model::UpdateHttpNamespaceOutcomeCallable UpdateHttpNamespaceCallable(const UpdateHttpNamespaceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::UpdateHttpNamespace, request);
        }
 
        template<typename UpdateHttpNamespaceRequestT = Model::UpdateHttpNamespaceRequest>
        void UpdateHttpNamespaceAsync(const UpdateHttpNamespaceRequestT& request, const UpdateHttpNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::UpdateHttpNamespace, request, handler, context);
        }
 
        virtual Model::UpdateInstanceCustomHealthStatusOutcome UpdateInstanceCustomHealthStatus(const Model::UpdateInstanceCustomHealthStatusRequest& request) const;
 
        template<typename UpdateInstanceCustomHealthStatusRequestT = Model::UpdateInstanceCustomHealthStatusRequest>
        Model::UpdateInstanceCustomHealthStatusOutcomeCallable UpdateInstanceCustomHealthStatusCallable(const UpdateInstanceCustomHealthStatusRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::UpdateInstanceCustomHealthStatus, request);
        }
 
        template<typename UpdateInstanceCustomHealthStatusRequestT = Model::UpdateInstanceCustomHealthStatusRequest>
        void UpdateInstanceCustomHealthStatusAsync(const UpdateInstanceCustomHealthStatusRequestT& request, const UpdateInstanceCustomHealthStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::UpdateInstanceCustomHealthStatus, request, handler, context);
        }
 
        virtual Model::UpdatePrivateDnsNamespaceOutcome UpdatePrivateDnsNamespace(const Model::UpdatePrivateDnsNamespaceRequest& request) const;
 
        template<typename UpdatePrivateDnsNamespaceRequestT = Model::UpdatePrivateDnsNamespaceRequest>
        Model::UpdatePrivateDnsNamespaceOutcomeCallable UpdatePrivateDnsNamespaceCallable(const UpdatePrivateDnsNamespaceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::UpdatePrivateDnsNamespace, request);
        }
 
        template<typename UpdatePrivateDnsNamespaceRequestT = Model::UpdatePrivateDnsNamespaceRequest>
        void UpdatePrivateDnsNamespaceAsync(const UpdatePrivateDnsNamespaceRequestT& request, const UpdatePrivateDnsNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::UpdatePrivateDnsNamespace, request, handler, context);
        }
 
        virtual Model::UpdatePublicDnsNamespaceOutcome UpdatePublicDnsNamespace(const Model::UpdatePublicDnsNamespaceRequest& request) const;
 
        template<typename UpdatePublicDnsNamespaceRequestT = Model::UpdatePublicDnsNamespaceRequest>
        Model::UpdatePublicDnsNamespaceOutcomeCallable UpdatePublicDnsNamespaceCallable(const UpdatePublicDnsNamespaceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::UpdatePublicDnsNamespace, request);
        }
 
        template<typename UpdatePublicDnsNamespaceRequestT = Model::UpdatePublicDnsNamespaceRequest>
        void UpdatePublicDnsNamespaceAsync(const UpdatePublicDnsNamespaceRequestT& request, const UpdatePublicDnsNamespaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::UpdatePublicDnsNamespace, request, handler, context);
        }
 
        virtual Model::UpdateServiceOutcome UpdateService(const Model::UpdateServiceRequest& request) const;
 
        template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
        Model::UpdateServiceOutcomeCallable UpdateServiceCallable(const UpdateServiceRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::UpdateService, request);
        }
 
        template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
        void UpdateServiceAsync(const UpdateServiceRequestT& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::UpdateService, request, handler, context);
        }
 
        virtual Model::UpdateServiceAttributesOutcome UpdateServiceAttributes(const Model::UpdateServiceAttributesRequest& request) const;
 
        template<typename UpdateServiceAttributesRequestT = Model::UpdateServiceAttributesRequest>
        Model::UpdateServiceAttributesOutcomeCallable UpdateServiceAttributesCallable(const UpdateServiceAttributesRequestT& request) const
        {
            return SubmitCallable(&ServiceDiscoveryClient::UpdateServiceAttributes, request);
        }
 
        template<typename UpdateServiceAttributesRequestT = Model::UpdateServiceAttributesRequest>
        void UpdateServiceAttributesAsync(const UpdateServiceAttributesRequestT& request, const UpdateServiceAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceDiscoveryClient::UpdateServiceAttributes, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ServiceDiscoveryEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ServiceDiscoveryClient>;
      void init(const ServiceDiscoveryClientConfiguration& clientConfiguration);
 
      ServiceDiscoveryClientConfiguration m_clientConfiguration;
      std::shared_ptr<ServiceDiscoveryEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ServiceDiscovery
} // namespace Aws