ElasticLoadBalancingClient.h

 
#pragma once
#include <aws/elasticloadbalancing/ElasticLoadBalancing_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/AmazonSerializableWebServiceRequest.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/xml/XmlSerializer.h>
#include <aws/elasticloadbalancing/ElasticLoadBalancingServiceClientModel.h>
 
namespace Aws
{
namespace ElasticLoadBalancing
{
  class AWS_ELASTICLOADBALANCING_API ElasticLoadBalancingClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<ElasticLoadBalancingClient>
  {
    public:
      typedef Aws::Client::AWSXMLClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ElasticLoadBalancingClientConfiguration ClientConfigurationType;
      typedef ElasticLoadBalancingEndpointProvider EndpointProviderType;
 
        ElasticLoadBalancingClient(const Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration& clientConfiguration = Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration(),
                                   std::shared_ptr<ElasticLoadBalancingEndpointProviderBase> endpointProvider = nullptr);
 
        ElasticLoadBalancingClient(const Aws::Auth::AWSCredentials& credentials,
                                   std::shared_ptr<ElasticLoadBalancingEndpointProviderBase> endpointProvider = nullptr,
                                   const Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration& clientConfiguration = Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration());
 
        ElasticLoadBalancingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                   std::shared_ptr<ElasticLoadBalancingEndpointProviderBase> endpointProvider = nullptr,
                                   const Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration& clientConfiguration = Aws::ElasticLoadBalancing::ElasticLoadBalancingClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ElasticLoadBalancingClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ElasticLoadBalancingClient(const Aws::Auth::AWSCredentials& credentials,
                                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ElasticLoadBalancingClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ElasticLoadBalancingClient();
 
 
        Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const;
 
 
        virtual Model::AddTagsOutcome AddTags(const Model::AddTagsRequest& request) const;
 
        template<typename AddTagsRequestT = Model::AddTagsRequest>
        Model::AddTagsOutcomeCallable AddTagsCallable(const AddTagsRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::AddTags, request);
        }
 
        template<typename AddTagsRequestT = Model::AddTagsRequest>
        void AddTagsAsync(const AddTagsRequestT& request, const AddTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::AddTags, request, handler, context);
        }
 
        virtual Model::ApplySecurityGroupsToLoadBalancerOutcome ApplySecurityGroupsToLoadBalancer(const Model::ApplySecurityGroupsToLoadBalancerRequest& request) const;
 
        template<typename ApplySecurityGroupsToLoadBalancerRequestT = Model::ApplySecurityGroupsToLoadBalancerRequest>
        Model::ApplySecurityGroupsToLoadBalancerOutcomeCallable ApplySecurityGroupsToLoadBalancerCallable(const ApplySecurityGroupsToLoadBalancerRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::ApplySecurityGroupsToLoadBalancer, request);
        }
 
        template<typename ApplySecurityGroupsToLoadBalancerRequestT = Model::ApplySecurityGroupsToLoadBalancerRequest>
        void ApplySecurityGroupsToLoadBalancerAsync(const ApplySecurityGroupsToLoadBalancerRequestT& request, const ApplySecurityGroupsToLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::ApplySecurityGroupsToLoadBalancer, request, handler, context);
        }
 
        virtual Model::AttachLoadBalancerToSubnetsOutcome AttachLoadBalancerToSubnets(const Model::AttachLoadBalancerToSubnetsRequest& request) const;
 
        template<typename AttachLoadBalancerToSubnetsRequestT = Model::AttachLoadBalancerToSubnetsRequest>
        Model::AttachLoadBalancerToSubnetsOutcomeCallable AttachLoadBalancerToSubnetsCallable(const AttachLoadBalancerToSubnetsRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::AttachLoadBalancerToSubnets, request);
        }
 
        template<typename AttachLoadBalancerToSubnetsRequestT = Model::AttachLoadBalancerToSubnetsRequest>
        void AttachLoadBalancerToSubnetsAsync(const AttachLoadBalancerToSubnetsRequestT& request, const AttachLoadBalancerToSubnetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::AttachLoadBalancerToSubnets, request, handler, context);
        }
 
        virtual Model::ConfigureHealthCheckOutcome ConfigureHealthCheck(const Model::ConfigureHealthCheckRequest& request) const;
 
        template<typename ConfigureHealthCheckRequestT = Model::ConfigureHealthCheckRequest>
        Model::ConfigureHealthCheckOutcomeCallable ConfigureHealthCheckCallable(const ConfigureHealthCheckRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::ConfigureHealthCheck, request);
        }
 
        template<typename ConfigureHealthCheckRequestT = Model::ConfigureHealthCheckRequest>
        void ConfigureHealthCheckAsync(const ConfigureHealthCheckRequestT& request, const ConfigureHealthCheckResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::ConfigureHealthCheck, request, handler, context);
        }
 
        virtual Model::CreateAppCookieStickinessPolicyOutcome CreateAppCookieStickinessPolicy(const Model::CreateAppCookieStickinessPolicyRequest& request) const;
 
        template<typename CreateAppCookieStickinessPolicyRequestT = Model::CreateAppCookieStickinessPolicyRequest>
        Model::CreateAppCookieStickinessPolicyOutcomeCallable CreateAppCookieStickinessPolicyCallable(const CreateAppCookieStickinessPolicyRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::CreateAppCookieStickinessPolicy, request);
        }
 
        template<typename CreateAppCookieStickinessPolicyRequestT = Model::CreateAppCookieStickinessPolicyRequest>
        void CreateAppCookieStickinessPolicyAsync(const CreateAppCookieStickinessPolicyRequestT& request, const CreateAppCookieStickinessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::CreateAppCookieStickinessPolicy, request, handler, context);
        }
 
        virtual Model::CreateLBCookieStickinessPolicyOutcome CreateLBCookieStickinessPolicy(const Model::CreateLBCookieStickinessPolicyRequest& request) const;
 
        template<typename CreateLBCookieStickinessPolicyRequestT = Model::CreateLBCookieStickinessPolicyRequest>
        Model::CreateLBCookieStickinessPolicyOutcomeCallable CreateLBCookieStickinessPolicyCallable(const CreateLBCookieStickinessPolicyRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::CreateLBCookieStickinessPolicy, request);
        }
 
        template<typename CreateLBCookieStickinessPolicyRequestT = Model::CreateLBCookieStickinessPolicyRequest>
        void CreateLBCookieStickinessPolicyAsync(const CreateLBCookieStickinessPolicyRequestT& request, const CreateLBCookieStickinessPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::CreateLBCookieStickinessPolicy, request, handler, context);
        }
 
        virtual Model::CreateLoadBalancerOutcome CreateLoadBalancer(const Model::CreateLoadBalancerRequest& request) const;
 
        template<typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
        Model::CreateLoadBalancerOutcomeCallable CreateLoadBalancerCallable(const CreateLoadBalancerRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::CreateLoadBalancer, request);
        }
 
        template<typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
        void CreateLoadBalancerAsync(const CreateLoadBalancerRequestT& request, const CreateLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::CreateLoadBalancer, request, handler, context);
        }
 
        virtual Model::CreateLoadBalancerListenersOutcome CreateLoadBalancerListeners(const Model::CreateLoadBalancerListenersRequest& request) const;
 
        template<typename CreateLoadBalancerListenersRequestT = Model::CreateLoadBalancerListenersRequest>
        Model::CreateLoadBalancerListenersOutcomeCallable CreateLoadBalancerListenersCallable(const CreateLoadBalancerListenersRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::CreateLoadBalancerListeners, request);
        }
 
        template<typename CreateLoadBalancerListenersRequestT = Model::CreateLoadBalancerListenersRequest>
        void CreateLoadBalancerListenersAsync(const CreateLoadBalancerListenersRequestT& request, const CreateLoadBalancerListenersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::CreateLoadBalancerListeners, request, handler, context);
        }
 
        virtual Model::CreateLoadBalancerPolicyOutcome CreateLoadBalancerPolicy(const Model::CreateLoadBalancerPolicyRequest& request) const;
 
        template<typename CreateLoadBalancerPolicyRequestT = Model::CreateLoadBalancerPolicyRequest>
        Model::CreateLoadBalancerPolicyOutcomeCallable CreateLoadBalancerPolicyCallable(const CreateLoadBalancerPolicyRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::CreateLoadBalancerPolicy, request);
        }
 
        template<typename CreateLoadBalancerPolicyRequestT = Model::CreateLoadBalancerPolicyRequest>
        void CreateLoadBalancerPolicyAsync(const CreateLoadBalancerPolicyRequestT& request, const CreateLoadBalancerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::CreateLoadBalancerPolicy, request, handler, context);
        }
 
        virtual Model::DeleteLoadBalancerOutcome DeleteLoadBalancer(const Model::DeleteLoadBalancerRequest& request) const;
 
        template<typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
        Model::DeleteLoadBalancerOutcomeCallable DeleteLoadBalancerCallable(const DeleteLoadBalancerRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DeleteLoadBalancer, request);
        }
 
        template<typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
        void DeleteLoadBalancerAsync(const DeleteLoadBalancerRequestT& request, const DeleteLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DeleteLoadBalancer, request, handler, context);
        }
 
        virtual Model::DeleteLoadBalancerListenersOutcome DeleteLoadBalancerListeners(const Model::DeleteLoadBalancerListenersRequest& request) const;
 
        template<typename DeleteLoadBalancerListenersRequestT = Model::DeleteLoadBalancerListenersRequest>
        Model::DeleteLoadBalancerListenersOutcomeCallable DeleteLoadBalancerListenersCallable(const DeleteLoadBalancerListenersRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DeleteLoadBalancerListeners, request);
        }
 
        template<typename DeleteLoadBalancerListenersRequestT = Model::DeleteLoadBalancerListenersRequest>
        void DeleteLoadBalancerListenersAsync(const DeleteLoadBalancerListenersRequestT& request, const DeleteLoadBalancerListenersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DeleteLoadBalancerListeners, request, handler, context);
        }
 
        virtual Model::DeleteLoadBalancerPolicyOutcome DeleteLoadBalancerPolicy(const Model::DeleteLoadBalancerPolicyRequest& request) const;
 
        template<typename DeleteLoadBalancerPolicyRequestT = Model::DeleteLoadBalancerPolicyRequest>
        Model::DeleteLoadBalancerPolicyOutcomeCallable DeleteLoadBalancerPolicyCallable(const DeleteLoadBalancerPolicyRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DeleteLoadBalancerPolicy, request);
        }
 
        template<typename DeleteLoadBalancerPolicyRequestT = Model::DeleteLoadBalancerPolicyRequest>
        void DeleteLoadBalancerPolicyAsync(const DeleteLoadBalancerPolicyRequestT& request, const DeleteLoadBalancerPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DeleteLoadBalancerPolicy, request, handler, context);
        }
 
        virtual Model::DeregisterInstancesFromLoadBalancerOutcome DeregisterInstancesFromLoadBalancer(const Model::DeregisterInstancesFromLoadBalancerRequest& request) const;
 
        template<typename DeregisterInstancesFromLoadBalancerRequestT = Model::DeregisterInstancesFromLoadBalancerRequest>
        Model::DeregisterInstancesFromLoadBalancerOutcomeCallable DeregisterInstancesFromLoadBalancerCallable(const DeregisterInstancesFromLoadBalancerRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DeregisterInstancesFromLoadBalancer, request);
        }
 
        template<typename DeregisterInstancesFromLoadBalancerRequestT = Model::DeregisterInstancesFromLoadBalancerRequest>
        void DeregisterInstancesFromLoadBalancerAsync(const DeregisterInstancesFromLoadBalancerRequestT& request, const DeregisterInstancesFromLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DeregisterInstancesFromLoadBalancer, request, handler, context);
        }
 
        virtual Model::DescribeAccountLimitsOutcome DescribeAccountLimits(const Model::DescribeAccountLimitsRequest& request = {}) const;
 
        template<typename DescribeAccountLimitsRequestT = Model::DescribeAccountLimitsRequest>
        Model::DescribeAccountLimitsOutcomeCallable DescribeAccountLimitsCallable(const DescribeAccountLimitsRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DescribeAccountLimits, request);
        }
 
        template<typename DescribeAccountLimitsRequestT = Model::DescribeAccountLimitsRequest>
        void DescribeAccountLimitsAsync(const DescribeAccountLimitsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAccountLimitsRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DescribeAccountLimits, request, handler, context);
        }
 
        virtual Model::DescribeInstanceHealthOutcome DescribeInstanceHealth(const Model::DescribeInstanceHealthRequest& request) const;
 
        template<typename DescribeInstanceHealthRequestT = Model::DescribeInstanceHealthRequest>
        Model::DescribeInstanceHealthOutcomeCallable DescribeInstanceHealthCallable(const DescribeInstanceHealthRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DescribeInstanceHealth, request);
        }
 
        template<typename DescribeInstanceHealthRequestT = Model::DescribeInstanceHealthRequest>
        void DescribeInstanceHealthAsync(const DescribeInstanceHealthRequestT& request, const DescribeInstanceHealthResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DescribeInstanceHealth, request, handler, context);
        }
 
        virtual Model::DescribeLoadBalancerAttributesOutcome DescribeLoadBalancerAttributes(const Model::DescribeLoadBalancerAttributesRequest& request) const;
 
        template<typename DescribeLoadBalancerAttributesRequestT = Model::DescribeLoadBalancerAttributesRequest>
        Model::DescribeLoadBalancerAttributesOutcomeCallable DescribeLoadBalancerAttributesCallable(const DescribeLoadBalancerAttributesRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DescribeLoadBalancerAttributes, request);
        }
 
        template<typename DescribeLoadBalancerAttributesRequestT = Model::DescribeLoadBalancerAttributesRequest>
        void DescribeLoadBalancerAttributesAsync(const DescribeLoadBalancerAttributesRequestT& request, const DescribeLoadBalancerAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DescribeLoadBalancerAttributes, request, handler, context);
        }
 
        virtual Model::DescribeLoadBalancerPoliciesOutcome DescribeLoadBalancerPolicies(const Model::DescribeLoadBalancerPoliciesRequest& request = {}) const;
 
        template<typename DescribeLoadBalancerPoliciesRequestT = Model::DescribeLoadBalancerPoliciesRequest>
        Model::DescribeLoadBalancerPoliciesOutcomeCallable DescribeLoadBalancerPoliciesCallable(const DescribeLoadBalancerPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DescribeLoadBalancerPolicies, request);
        }
 
        template<typename DescribeLoadBalancerPoliciesRequestT = Model::DescribeLoadBalancerPoliciesRequest>
        void DescribeLoadBalancerPoliciesAsync(const DescribeLoadBalancerPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLoadBalancerPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DescribeLoadBalancerPolicies, request, handler, context);
        }
 
        virtual Model::DescribeLoadBalancerPolicyTypesOutcome DescribeLoadBalancerPolicyTypes(const Model::DescribeLoadBalancerPolicyTypesRequest& request = {}) const;
 
        template<typename DescribeLoadBalancerPolicyTypesRequestT = Model::DescribeLoadBalancerPolicyTypesRequest>
        Model::DescribeLoadBalancerPolicyTypesOutcomeCallable DescribeLoadBalancerPolicyTypesCallable(const DescribeLoadBalancerPolicyTypesRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DescribeLoadBalancerPolicyTypes, request);
        }
 
        template<typename DescribeLoadBalancerPolicyTypesRequestT = Model::DescribeLoadBalancerPolicyTypesRequest>
        void DescribeLoadBalancerPolicyTypesAsync(const DescribeLoadBalancerPolicyTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLoadBalancerPolicyTypesRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DescribeLoadBalancerPolicyTypes, request, handler, context);
        }
 
        virtual Model::DescribeLoadBalancersOutcome DescribeLoadBalancers(const Model::DescribeLoadBalancersRequest& request = {}) const;
 
        template<typename DescribeLoadBalancersRequestT = Model::DescribeLoadBalancersRequest>
        Model::DescribeLoadBalancersOutcomeCallable DescribeLoadBalancersCallable(const DescribeLoadBalancersRequestT& request = {}) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DescribeLoadBalancers, request);
        }
 
        template<typename DescribeLoadBalancersRequestT = Model::DescribeLoadBalancersRequest>
        void DescribeLoadBalancersAsync(const DescribeLoadBalancersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeLoadBalancersRequestT& request = {}) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DescribeLoadBalancers, request, handler, context);
        }
 
        virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request) const;
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DescribeTags, request);
        }
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        void DescribeTagsAsync(const DescribeTagsRequestT& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DescribeTags, request, handler, context);
        }
 
        virtual Model::DetachLoadBalancerFromSubnetsOutcome DetachLoadBalancerFromSubnets(const Model::DetachLoadBalancerFromSubnetsRequest& request) const;
 
        template<typename DetachLoadBalancerFromSubnetsRequestT = Model::DetachLoadBalancerFromSubnetsRequest>
        Model::DetachLoadBalancerFromSubnetsOutcomeCallable DetachLoadBalancerFromSubnetsCallable(const DetachLoadBalancerFromSubnetsRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DetachLoadBalancerFromSubnets, request);
        }
 
        template<typename DetachLoadBalancerFromSubnetsRequestT = Model::DetachLoadBalancerFromSubnetsRequest>
        void DetachLoadBalancerFromSubnetsAsync(const DetachLoadBalancerFromSubnetsRequestT& request, const DetachLoadBalancerFromSubnetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DetachLoadBalancerFromSubnets, request, handler, context);
        }
 
        virtual Model::DisableAvailabilityZonesForLoadBalancerOutcome DisableAvailabilityZonesForLoadBalancer(const Model::DisableAvailabilityZonesForLoadBalancerRequest& request) const;
 
        template<typename DisableAvailabilityZonesForLoadBalancerRequestT = Model::DisableAvailabilityZonesForLoadBalancerRequest>
        Model::DisableAvailabilityZonesForLoadBalancerOutcomeCallable DisableAvailabilityZonesForLoadBalancerCallable(const DisableAvailabilityZonesForLoadBalancerRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::DisableAvailabilityZonesForLoadBalancer, request);
        }
 
        template<typename DisableAvailabilityZonesForLoadBalancerRequestT = Model::DisableAvailabilityZonesForLoadBalancerRequest>
        void DisableAvailabilityZonesForLoadBalancerAsync(const DisableAvailabilityZonesForLoadBalancerRequestT& request, const DisableAvailabilityZonesForLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::DisableAvailabilityZonesForLoadBalancer, request, handler, context);
        }
 
        virtual Model::EnableAvailabilityZonesForLoadBalancerOutcome EnableAvailabilityZonesForLoadBalancer(const Model::EnableAvailabilityZonesForLoadBalancerRequest& request) const;
 
        template<typename EnableAvailabilityZonesForLoadBalancerRequestT = Model::EnableAvailabilityZonesForLoadBalancerRequest>
        Model::EnableAvailabilityZonesForLoadBalancerOutcomeCallable EnableAvailabilityZonesForLoadBalancerCallable(const EnableAvailabilityZonesForLoadBalancerRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::EnableAvailabilityZonesForLoadBalancer, request);
        }
 
        template<typename EnableAvailabilityZonesForLoadBalancerRequestT = Model::EnableAvailabilityZonesForLoadBalancerRequest>
        void EnableAvailabilityZonesForLoadBalancerAsync(const EnableAvailabilityZonesForLoadBalancerRequestT& request, const EnableAvailabilityZonesForLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::EnableAvailabilityZonesForLoadBalancer, request, handler, context);
        }
 
        virtual Model::ModifyLoadBalancerAttributesOutcome ModifyLoadBalancerAttributes(const Model::ModifyLoadBalancerAttributesRequest& request) const;
 
        template<typename ModifyLoadBalancerAttributesRequestT = Model::ModifyLoadBalancerAttributesRequest>
        Model::ModifyLoadBalancerAttributesOutcomeCallable ModifyLoadBalancerAttributesCallable(const ModifyLoadBalancerAttributesRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::ModifyLoadBalancerAttributes, request);
        }
 
        template<typename ModifyLoadBalancerAttributesRequestT = Model::ModifyLoadBalancerAttributesRequest>
        void ModifyLoadBalancerAttributesAsync(const ModifyLoadBalancerAttributesRequestT& request, const ModifyLoadBalancerAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::ModifyLoadBalancerAttributes, request, handler, context);
        }
 
        virtual Model::RegisterInstancesWithLoadBalancerOutcome RegisterInstancesWithLoadBalancer(const Model::RegisterInstancesWithLoadBalancerRequest& request) const;
 
        template<typename RegisterInstancesWithLoadBalancerRequestT = Model::RegisterInstancesWithLoadBalancerRequest>
        Model::RegisterInstancesWithLoadBalancerOutcomeCallable RegisterInstancesWithLoadBalancerCallable(const RegisterInstancesWithLoadBalancerRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::RegisterInstancesWithLoadBalancer, request);
        }
 
        template<typename RegisterInstancesWithLoadBalancerRequestT = Model::RegisterInstancesWithLoadBalancerRequest>
        void RegisterInstancesWithLoadBalancerAsync(const RegisterInstancesWithLoadBalancerRequestT& request, const RegisterInstancesWithLoadBalancerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::RegisterInstancesWithLoadBalancer, request, handler, context);
        }
 
        virtual Model::RemoveTagsOutcome RemoveTags(const Model::RemoveTagsRequest& request) const;
 
        template<typename RemoveTagsRequestT = Model::RemoveTagsRequest>
        Model::RemoveTagsOutcomeCallable RemoveTagsCallable(const RemoveTagsRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::RemoveTags, request);
        }
 
        template<typename RemoveTagsRequestT = Model::RemoveTagsRequest>
        void RemoveTagsAsync(const RemoveTagsRequestT& request, const RemoveTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::RemoveTags, request, handler, context);
        }
 
        virtual Model::SetLoadBalancerListenerSSLCertificateOutcome SetLoadBalancerListenerSSLCertificate(const Model::SetLoadBalancerListenerSSLCertificateRequest& request) const;
 
        template<typename SetLoadBalancerListenerSSLCertificateRequestT = Model::SetLoadBalancerListenerSSLCertificateRequest>
        Model::SetLoadBalancerListenerSSLCertificateOutcomeCallable SetLoadBalancerListenerSSLCertificateCallable(const SetLoadBalancerListenerSSLCertificateRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::SetLoadBalancerListenerSSLCertificate, request);
        }
 
        template<typename SetLoadBalancerListenerSSLCertificateRequestT = Model::SetLoadBalancerListenerSSLCertificateRequest>
        void SetLoadBalancerListenerSSLCertificateAsync(const SetLoadBalancerListenerSSLCertificateRequestT& request, const SetLoadBalancerListenerSSLCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::SetLoadBalancerListenerSSLCertificate, request, handler, context);
        }
 
        virtual Model::SetLoadBalancerPoliciesForBackendServerOutcome SetLoadBalancerPoliciesForBackendServer(const Model::SetLoadBalancerPoliciesForBackendServerRequest& request) const;
 
        template<typename SetLoadBalancerPoliciesForBackendServerRequestT = Model::SetLoadBalancerPoliciesForBackendServerRequest>
        Model::SetLoadBalancerPoliciesForBackendServerOutcomeCallable SetLoadBalancerPoliciesForBackendServerCallable(const SetLoadBalancerPoliciesForBackendServerRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::SetLoadBalancerPoliciesForBackendServer, request);
        }
 
        template<typename SetLoadBalancerPoliciesForBackendServerRequestT = Model::SetLoadBalancerPoliciesForBackendServerRequest>
        void SetLoadBalancerPoliciesForBackendServerAsync(const SetLoadBalancerPoliciesForBackendServerRequestT& request, const SetLoadBalancerPoliciesForBackendServerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::SetLoadBalancerPoliciesForBackendServer, request, handler, context);
        }
 
        virtual Model::SetLoadBalancerPoliciesOfListenerOutcome SetLoadBalancerPoliciesOfListener(const Model::SetLoadBalancerPoliciesOfListenerRequest& request) const;
 
        template<typename SetLoadBalancerPoliciesOfListenerRequestT = Model::SetLoadBalancerPoliciesOfListenerRequest>
        Model::SetLoadBalancerPoliciesOfListenerOutcomeCallable SetLoadBalancerPoliciesOfListenerCallable(const SetLoadBalancerPoliciesOfListenerRequestT& request) const
        {
            return SubmitCallable(&ElasticLoadBalancingClient::SetLoadBalancerPoliciesOfListener, request);
        }
 
        template<typename SetLoadBalancerPoliciesOfListenerRequestT = Model::SetLoadBalancerPoliciesOfListenerRequest>
        void SetLoadBalancerPoliciesOfListenerAsync(const SetLoadBalancerPoliciesOfListenerRequestT& request, const SetLoadBalancerPoliciesOfListenerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ElasticLoadBalancingClient::SetLoadBalancerPoliciesOfListener, request, handler, context);
        }
 
 
        void OverrideEndpoint(const Aws::String& endpoint);
        std::shared_ptr<ElasticLoadBalancingEndpointProviderBase>& accessEndpointProvider();
  private:
        friend class Aws::Client::ClientWithAsyncTemplateMethods<ElasticLoadBalancingClient>;
        void init(const ElasticLoadBalancingClientConfiguration& clientConfiguration);
 
        ElasticLoadBalancingClientConfiguration m_clientConfiguration;
        std::shared_ptr<ElasticLoadBalancingEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ElasticLoadBalancing
} // namespace Aws